{"id":1140,"date":"2024-04-05T13:10:58","date_gmt":"2024-04-05T11:10:58","guid":{"rendered":"https:\/\/albooms.fr\/?p=1140"},"modified":"2024-04-05T13:10:59","modified_gmt":"2024-04-05T11:10:59","slug":"sauvons-les-tortues","status":"publish","type":"post","link":"https:\/\/albooms.fr\/?p=1140","title":{"rendered":"Sauvons les tortues!"},"content":{"rendered":"\n<p><a href=\"https:\/\/albooms.fr\/?p=1117\">Apr\u00e8s avoir expliqu\u00e9<\/a> comment les syst\u00e8mes \u00e9ducatifs ont pu assimiler les techniques num\u00e9riques invent\u00e9es par des personnalit\u00e9s du MIT comme Seymour PAPERT et Mitchel RESNICK, sans pour autant chercher \u00e0 s&rsquo;en accommoder, il me semble qu&rsquo;il est temps de remonter nos manches et (r\u00e9)explorer ces outils pour comprendre ce qu&rsquo;ils avaient de potentiellement r\u00e9volutionnaire (&#8230; ou pas). Il y a sans doute quelques bonnes raisons pour que ces outils ne soient pas d\u00e9ploy\u00e9s comme esp\u00e9r\u00e9. On peut \u00e9galement s&rsquo;interroger sur le fait que PAPERT ou RESNICK aient pu se laisser emporter par une forme d&rsquo;enthousiasme geek, sans pour autant apporter une solution r\u00e9ellement viable dans l&rsquo;\u00e9cole. <\/p>\n\n\n\n<p>Certains auteurs se sont d\u00e9j\u00e0 charg\u00e9s d&rsquo;identifier les limites des approches \u00e9ducatives avec les micromondes (Linard, 2002). Il ne s&rsquo;agit pas ici de refaire cette analyse, mais bel et bien de savoir si quelque chose m\u00e9rite d&rsquo;\u00eatre pr\u00e9serv\u00e9 dans les approches propos\u00e9es par le MIT il y a un demi-si\u00e8cle. En effet, si les micromondes pr\u00e9sentent vraisemblablement un certain nombre d&rsquo;\u00e9cueils, il faut aussi constater qu&rsquo;il sont souvent mal utilis\u00e9s. C&rsquo;est par exemple le cas avec les logiciels de g\u00e9om\u00e9trie dynamique, dont les usages usuels d\u00e9passent difficilement le trac\u00e9 de figures en contexte de classe. Autrement dit, il parait difficile de savoir si ce sont les micromondes qui ne sont pas f\u00e9conds, ou si c&rsquo;est leur m\u00e9susage qui les a st\u00e9rilis\u00e9s. Il parait pr\u00e9matur\u00e9 de jeter le b\u00e9b\u00e9 avec l&rsquo;eau du bain. <\/p>\n\n\n\n<h5 class=\"wp-block-heading\">Retour en 1980<\/h5>\n\n\n\n<p>Comme d&rsquo;habitude, je m&rsquo;\u00e9vertuerai \u00e0 d\u00e9montrer qu&rsquo;avant de sauter sur la premi\u00e8re innovation gratifi\u00e9e d&rsquo;une \u00e9pith\u00e8te p\u00e9dante \u00e0 base de novlangue (un petit retour au <a href=\"https:\/\/albooms.fr\/ressources\/gerard\/gerard.html\">G.\u00e9.r.a.r.d.<\/a> ne peut pas faire de mal), il suffit parfois de regarder chez ces pionniers. Ceux-ci n&rsquo;avaient, au d\u00e9but des ann\u00e9es 80, que des ordinateurs en 8 bit, et il n&rsquo;\u00e9tait pas question de mettre des effets de sapins de No\u00ebl partout dans les logiciels pour faire illusion de modernitude ou d&rsquo;innovationisme.  <\/p>\n\n\n\n<p>L&rsquo;histoire de la tortue promobile T2 Jeulin est int\u00e9ressante \u00e0 plus d&rsquo;un titre. \u00c9videmment, elle est une copie des tortues du MIT, peut-\u00eatre m\u00eame un peu d\u00e9pass\u00e9e techniquement. La Yellow Turtle est con\u00e7ue en 1969 et Irving, la premi\u00e8re tortue sans fil radiocommand\u00e9e, voit le jour en 1972. En 1981, la tortue T2 est \u00e9quip\u00e9e d&rsquo;un cordon ombilical qui disparaitra avec la T3 au profit d&rsquo;une commande infrarouge (un choix \u00e9videmment discutable pour investir tout l&rsquo;espace). Les tortues Jeulin sont le fruit d\u2019une collaborations entre l\u2019INRP, la soci\u00e9t\u00e9 Jeulin et le centre de formation des professeurs techniques (CFPT) de Cachan. Dans mes p\u00e9r\u00e9grinations sur le web, j&rsquo;ai \u00e9t\u00e9 tr\u00e8s heureux de trouver ce dossier d&rsquo;\u00e9tude de la tortue par des \u00e9l\u00e8ves professeurs (<a href=\"https:\/\/sitelec.org\/download.php?filename=themes\/tortue\/paccap.pdf\">voir ici<\/a>) de Cachan.<\/p>\n\n\n\n<p>Mais l\u00e0 n&rsquo;est pas le plus important, cette tortue, tout en \u00e9tant \u00ab\u00a0logo compatible\u00a0\u00bb en utilisant les ordinateurs Thomson, est aussi con\u00e7ue pour s&rsquo;\u00e9loigner sensiblement du logo afin d&rsquo;\u00eatre introduite en maternelle. Plus pr\u00e9cis\u00e9ment, elle reprend quelques id\u00e9es du Logo, comme la commande de d\u00e9placement associ\u00e9e \u00e0 une distance, mais sans passer par la saisie du texte. Elle utilise alors, un codage binaire selon le bon vieux principe des cartes perfor\u00e9es. <\/p>\n\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"938\" src=\"https:\/\/albooms.fr\/wp-content\/uploads\/2024\/03\/cartes-jeulin-1024x938.jpg\" alt=\"\" class=\"wp-image-1145\" srcset=\"https:\/\/albooms.fr\/wp-content\/uploads\/2024\/03\/cartes-jeulin-1024x938.jpg 1024w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/03\/cartes-jeulin-300x275.jpg 300w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/03\/cartes-jeulin-768x703.jpg 768w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/03\/cartes-jeulin-1536x1407.jpg 1536w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/03\/cartes-jeulin.jpg 1547w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p>Contrairement au logo, les cartes perfor\u00e9es permettent de d\u00e9buter la programmation avant de maitriser l&rsquo;\u00e9criture.<\/p>\n\n\n\n<p>Certes, on peut discuter de l&rsquo;ergonomie de ces cartes, notamment la trop faible diff\u00e9rence entre les cartes avance de 1cm, de 10 cm et de 20 cm pour un non-lecteur, mais elles permettent le codage par un geste plus simple que l&rsquo;\u00e9criture, f\u00fbt-elle au clavier.<\/p>\n\n\n\n<p>Un petit d\u00e9tour par les archives de <a href=\"https:\/\/publimath.univ-irem.fr\/\">Publimaths <\/a>nous fait d\u00e9couvrir quelques p\u00e9pites, dont <a href=\"https:\/\/publimath.univ-irem.fr\/numerisation\/GN\/IGR85040\/IGR85040.pdf\">ce compte rendu d&rsquo;activit\u00e9 de 1985 en grande section<\/a>. Les activit\u00e9s de rep\u00e9rage et de trac\u00e9 sont visiblement complexes, comme l&rsquo;indique l&rsquo;extrait ci-dessous.<\/p>\n\n\n\n<figure class=\"wp-block-image aligncenter size-full\"><img loading=\"lazy\" decoding=\"async\" width=\"648\" height=\"197\" src=\"https:\/\/albooms.fr\/wp-content\/uploads\/2024\/03\/Capture-decran-2024-03-04-085515.png\" alt=\"\" class=\"wp-image-1146\" srcset=\"https:\/\/albooms.fr\/wp-content\/uploads\/2024\/03\/Capture-decran-2024-03-04-085515.png 648w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/03\/Capture-decran-2024-03-04-085515-300x91.png 300w\" sizes=\"auto, (max-width: 648px) 100vw, 648px\" \/><figcaption class=\"wp-element-caption\">Ch\u00e2teau-fort dessin\u00e9 \u00e0 la tortue de sol par des \u00e9l\u00e8ves de GS maternelle<\/figcaption><\/figure>\n\n\n\n<h5 class=\"wp-block-heading\">O\u00f9 acheter une tortue en 2023?<\/h5>\n\n\n\n<p>Il existe des tortues de sol, mais elles sont \u00ab\u00a0relativement ch\u00e8res\u00a0\u00bb (par exemple les Thymio) ou tr\u00e8s limit\u00e9es (par exemple les Bee-bot). Aucune ne passe par la programmation par carte qui me parait int\u00e9ressante \u00e0 plus d&rsquo;un \u00e9gard, en particulier pour de jeunes enfants. <\/p>\n\n\n\n<p>Il me semble \u00e9galement que fabriquer sa carte perfor\u00e9e codant un caract\u00e8re ASCII n&rsquo;est pas un geste anodin pour comprendre le fonctionnement d&rsquo;un ordinateur. Entrer les commandes manuellement (au sens strict du terme) puis attendre leur ex\u00e9cution et la fin de celle-ci par la machine n&rsquo;est pas anodin non plus. Je parlerai peut-\u00eatre prochainement de la question \u00ab\u00a0oubli\u00e9e\u00a0\u00bb de la s\u00e9quentialit\u00e9 dans la programmation des objets technique.<\/p>\n\n\n\n<p>Peu satisfait de l&rsquo;offre commerciale, j&rsquo;ai donc recon\u00e7u un robot sous Arduino pilotable pars carte perfor\u00e9es en m&rsquo;appuyant sur les choix techniques de Jeulin de 1980. La fabrication de ce robot fera l&rsquo;objet d&rsquo;un prochain billet, mais, en attendant, voici quelques photographies et une petite vid\u00e9o de d\u00e9monstration.<\/p>\n\n\n\n<figure class=\"wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-1 is-layout-flex wp-block-gallery-is-layout-flex\">\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"768\" height=\"1024\" data-id=\"1151\" src=\"https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/IMG_20240330_140203041-1-768x1024.jpg\" alt=\"\" class=\"wp-image-1151\" srcset=\"https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/IMG_20240330_140203041-1-768x1024.jpg 768w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/IMG_20240330_140203041-1-225x300.jpg 225w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/IMG_20240330_140203041-1-1152x1536.jpg 1152w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/IMG_20240330_140203041-1-1536x2048.jpg 1536w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/IMG_20240330_140203041-1-scaled.jpg 1920w\" sizes=\"auto, (max-width: 768px) 100vw, 768px\" \/><figcaption class=\"wp-element-caption\">Tortue large<\/figcaption><\/figure>\n\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"768\" data-id=\"1152\" src=\"https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/robot-tortue-1024x768.jpg\" alt=\"\" class=\"wp-image-1152\" srcset=\"https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/robot-tortue-1024x768.jpg 1024w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/robot-tortue-300x225.jpg 300w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/robot-tortue-768x576.jpg 768w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/robot-tortue-1536x1152.jpg 1536w, https:\/\/albooms.fr\/wp-content\/uploads\/2024\/04\/robot-tortue-2048x1536.jpg 2048w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><figcaption class=\"wp-element-caption\">Tortue \u00e9troite<\/figcaption><\/figure>\n<\/figure>\n\n\n\n<p> <\/p>\n\n\n\n<figure class=\"wp-block-embed is-type-video is-provider-youtube wp-block-embed-youtube wp-embed-aspect-16-9 wp-has-aspect-ratio\"><div class=\"wp-block-embed__wrapper\">\n<iframe loading=\"lazy\" title=\"demo tortue etroite\" width=\"500\" height=\"281\" src=\"https:\/\/www.youtube.com\/embed\/fLSijcPy4Qk?feature=oembed\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen><\/iframe>\n<\/div><\/figure>\n\n\n\n<h5 class=\"wp-block-heading\">fichier STL et code<\/h5>\n\n\n\n<p>Les mod\u00e8les pour l&rsquo;impression 3D sont disponibles sur les liens ci-dessous. <\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><a href=\"https:\/\/cults3d.com\/fr\/mod%C3%A8le-3d\/gadget\/robot-tortue-a-imprimer\">Tortue \u00e9troite<\/a><\/li>\n\n\n\n<li><a href=\"https:\/\/cults3d.com\/fr\/mod%C3%A8le-3d\/gadget\/robot-tortue-a-imprimer-version-large\">Tortue large<\/a><\/li>\n<\/ul>\n\n\n\n<p>Le code du robot tortue est disponible ci-dessous. Il faut param\u00e9trer la largeur de l&#8217;empattement (variable apr\u00e8s montage) et le diam\u00e8tre des roues. Le r\u00e9glage fin de ces param\u00e8tre donne de la pr\u00e9cisionlors du trac\u00e9 des figures.<\/p>\n\n\n\n<pre class=\"wp-block-code has-tertiary-color has-white-background-color has-text-color has-background has-link-color has-small-font-size wp-elements-67e3b712c6a36ff525f95a436b22cc2b\"><code>\/********************************************\n***         Programme robot tortue        ***\n***            Alexandre BOOMS            ***\n***              CC-BY-NC-SA              ***  \n********************************************\/\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/Biblioth\u00e8ques\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n#include &lt;Servo.h> \/\/ biblioth\u00e8que servomoteur\n#include &lt;Adafruit_NeoPixel.h> \/\/ biblioth\u00e8que LED RGB\n#include &lt;SoftwareSerial.h> \/\/ Bilioth\u00e8que BlueTooth\n\n\/\/ configuration servo\nint broche_servo = 7; \/\/ d\u00e9fini la broche du servomoteur\nint angle_stylo_B = 0; \/\/ angle du servo avec le stylo en bas\nint angle_stylo_H = 90; \/\/ angle du servo avec le stylo en bas\nServo Servo_stylo; \/\/ nom du servo\n\n\/\/  Variables d'ecoute du port s\u00e9rie\nString ent_serie; \/\/ r\u00e9cup\u00e8re la chaine de caract\u00e8re entr\u00e9e sur le port s\u00e9rie\nint ENTREE;\n\n\/\/ Variables de d\u00e9placement\nfloat dia_roue=59.9; \/\/       diam\u00e8tre des roues (augmentation = diminution distance parcourue)\nfloat empattement=112.9; \/\/    empattement (augmentation = augmentation de la rotation angulaire)\nint Paspartour=512; \/\/    voir la documentation du r\u00e9ducteur\nint duree_delai=8; \/\/      Attente entre pas in ms (10 mini)\nint distance; \/\/ distance \u00e0 parcourir\nfloat AvanceParPas = (3.1415926 * dia_roue)\/Paspartour; \/\/calcule l'avance d'un pas\nint steps ;\n\n\/\/ Variables moteurs pas \u00e0 pas \nint broches_MoteurG&#91;4] = { 2, 3, 4, 5};\nint broches_MoteurD&#91;4] = { 10, 11, 12, 13};\n\nconst  byte dextro&#91;4]&#91;4] =  {  \/\/rotation sens horaire depuis le moteur vers l'ext\u00e9rieur\n                          {HIGH, LOW, LOW, HIGH},\n                          {LOW, LOW, HIGH, HIGH},\n                          {LOW, HIGH, HIGH, LOW},\n                          {HIGH, HIGH, LOW, LOW},                              \n                          };\n\nconst  byte levo&#91;4]&#91;4] =  { \/\/rotation sens anti-horaire depuis le moteur vers l'ext\u00e9rieur \n                          {HIGH, HIGH, LOW, LOW},\n                          {LOW, HIGH, HIGH, LOW},\n                          {LOW, LOW, HIGH, HIGH},\n                          {HIGH, LOW, LOW, HIGH},     \n                          };\n\n\/\/ configuration speaker\nint broche_speaker = 6; \/\/ Broche du speaker\nint speak = 0; \/\/ Flag pour emp\u00eacher le bip apr\u00e8s l'appel d'une boucle sonore\n\n\/\/ configuration led RGB\nint broche_RGB =8; \/\/ Broche de la led mutlicolore\nAdafruit_NeoPixel led_RGB = Adafruit_NeoPixel(1, broche_RGB, NEO_GRB + NEO_KHZ800);\n\n\/\/ configuration du port s\u00e9rie BlueTooth\nint Rx=0;\nint Tx=1;\nSoftwareSerial BTmySerial(Rx, Tx); \/\/ RX, TX\n\n\n                                  \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n                                  \/\/ INITIALISATION  \/\/\n                                  \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\nvoid setup() \n{\n  \/\/ Initialise le port s\u00e9rie \n  BTmySerial.begin(9600); \/\/ ouvre le port s\u00e9rie et fixe le d\u00e9bit \u00e0 9600 bauds\n\n  \/\/ initialisation le Servo_stylo\n  Servo_stylo.attach(broche_servo); \/\/ d\u00e9claration de la broche\n  pinMode(broche_servo, OUTPUT); \/\/ met la broche en mode entr\u00e9e\n  stylo_H(); \/\/ monter le porte stylo en haut\n  digitalWrite (broche_servo, LOW); \/\/ coupe la broche du servo pour \u00e9conomiser les batteries\n  delay(200);\n       \n  \/\/ initialisation Moteurs pas \u00e0 pas \n    for(int pin=0; pin&lt;4; pin++)\n      {\n      pinMode(broches_MoteurG&#91;pin], OUTPUT); \/\/ met les broches du moteur gauche en mode sortie\n      digitalWrite(broches_MoteurG&#91;pin], LOW); \/\/ coupe la broche du moteur gauche pour \u00e9conomiser les batteries\n      pinMode(broches_MoteurD&#91;pin], OUTPUT); \/\/ met les broches du moteur droit en mode sortie\n      digitalWrite(broches_MoteurD&#91;pin], LOW); \/\/ coupe la broche du moteur droit pour \u00e9conomiser les batteries\n      }\n\n    \/\/ configure le BT\n    BTConfig();\n    \n    delay(1000);\n    BTmySerial.flush(); \/\/ Purge le buffer\n    \n    \/\/ Fais bouger le robot\n    avance(5);\n    recule(5);\n    tournegauche(5);\n    tournedroite(5);\n\n    \/\/ joue la m\u00e9lodie pour signaler que la tortue est pr\u00eate \n    melodie();\n\n}\n\n                                  \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n                                  \/\/ PROGRAMME PCPAL \/\/\n                                  \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid loop() \n{\n  \/\/ ecoute du port s\u00e9rie\n  if (BTmySerial.available()) \/\/ecoute le port s\u00e9rie si re\u00e7oit une donn\u00e9e\n        { \n          ent_serie = BTmySerial.readString(); \/\/ lit la chaine envoy\u00e9e sur le port s\u00e9rie\n          ENTREE = ent_serie.charAt(0);  \/\/ extrait le premier caract\u00e8re (s\u00e9curit\u00e9 pour traiter les commandes une \u00e0 une);        \n          BTmySerial.println(ENTREE);  \/\/ lit le premier caract\u00e8re dans le moniteur\n        \n        if (ENTREE == 66){stylo_B();} \/\/ B= stylo bas\n        else if (ENTREE == 72){stylo_H();} \/\/ H = stylo haut\n        else if (ENTREE == 97){avance(0);} \/\/ a = avance d'un pas\n        else if (ENTREE == 115){avance(10);} \/\/ s = avance de 10 mm\n        else if (ENTREE == 65){avance(100);} \/\/ A = avance de 100 mm\n        else if (ENTREE == 70){avance(200);} \/\/ F = avance de 200 mm\n        else if (ENTREE == 114){recule(0);} \/\/ r = recul d'un pas\n        else if (ENTREE == 116){recule(10);} \/\/t = recule de 10 mm\n        else if (ENTREE == 82){recule(100);} \/\/R = recule de 10 mm\n        else if (ENTREE == 85){recule(200);} \/\/U = recule de 10 mm\n        else if (ENTREE == 103){tournegauche(0);} \/\/ g = tourne d'un pas gauche\n        else if (ENTREE == 118){tournegauche(1);} \/\/ v = tourne 1 degr\u00e9 gauche\n        else if (ENTREE == 71){tournegauche(15);} \/\/ G = tourne 15 degr\u00e9 gauche\n        else if (ENTREE == 99){tournegauche(30);} \/\/ c = tourne 30 degr\u00e9 gauche\n        else if (ENTREE == 102){tournegauche(45);} \/\/ f = tourne 45 degr\u00e9 gauche\n        else if (ENTREE == 105){tournegauche(60);} \/\/ i = tourne 60 degr\u00e9 gauche\n        else if (ENTREE == 108){tournegauche(90);} \/\/ l = tourne 90 degr\u00e9 gauche\n        else if (ENTREE == 111){tournegauche(120);} \/\/ o = tourne 120 degr\u00e9 gauche\n        else if (ENTREE == 100){tournedroite(0);} \/\/ d = tourne d'un pas droite\n        else if (ENTREE == 117){tournedroite(1);} \/\/ u = tourne 1 degr\u00e9 droite\n        else if (ENTREE == 68){tournedroite(15);} \/\/ D = tourne 15 degr\u00e9 droite\n        else if (ENTREE == 98){tournedroite(30);} \/\/ b = tourne 30 degr\u00e9 droite\n        else if (ENTREE == 101){tournedroite(45);} \/\/ e = tourne 45 degr\u00e9 droite\n        else if (ENTREE == 104){tournedroite(60);} \/\/ h = tourne 60 degr\u00e9 droite\n        else if (ENTREE == 107){tournedroite(90);} \/\/ k = tourne 90 degr\u00e9 droite\n        else if (ENTREE == 110){tournedroite(120);} \/\/ n = tourne 120 degr\u00e9 droite\n        else if (ENTREE == 49){avantdroite(100);} \/\/ 1 = arc de cercle av dr rayon 100 mm\n        else if (ENTREE == 53){avantdroite(200);} \/\/ 5 = arc de cercle av dr rayon 200 mm\n        else if (ENTREE == 50){avantgauche(100);} \/\/ 2 = arc de cercle av g rayon 100 mm\n        else if (ENTREE == 54){avantgauche(200);} \/\/ 6 = arc de cercle av g rayon 200 mm\n        else if (ENTREE == 51){arrieregauche(100);} \/\/ 3 = arc de cercle ar g rayon 100 mm\n        else if (ENTREE == 55){arrieregauche(200);} \/\/ 7 = arc de cercle ar g rayon 200 mm\n        else if (ENTREE == 52){arrieredroite(100);} \/\/ 4 = arc de cercle ar dr rayon 100 mm\n        else if (ENTREE == 56){arrieredroite(200);} \/\/ 8 = arc de cercle ar dr rayon 200 mm\n        else if (ENTREE == 74){melodie();} \/\/ J = joue une m\u00e9lodie\n        else if (ENTREE == 75){bip();} \/\/ K = bip\n        else if (ENTREE == 80){rale();} \/\/ P = rale\n        else if (ENTREE == 43){allume_blanc();} \/\/ + = allume la led en blanc\n        else if (ENTREE == 45){eteins_led();} \/\/ - = allume la led en blanc\n        else if (ENTREE == 33){allume_bleu();} \/\/ ! = allume la led en bleu\n        else if (ENTREE == 34){allume_vert();} \/\/ \" = allume la led en vert\n        else if (ENTREE == 35){allume_rouge();} \/\/ # = allume la led en rouge\n        else if (ENTREE == 36){allume_violet();} \/\/ $ = allume la led en violet\n        else if (ENTREE == 37){allume_turquoise();} \/\/ % = allume la led en turquoise\n        else if (ENTREE == 38){allume_jaune();} \/\/ &amp; = allume la led en jaune\n        else if (ENTREE == 88){test_carre();}  \n        else if (ENTREE == 121){demi_tour();}      \n        }\n}\n\n \n\n                              \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n                              \/\/ SOUS PROGRAMMES \/\/\n                              \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\n\n\/***************************************************************************\n *  gestion du porte sylo\n ***************************************************************************\/\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ rel\u00e8ve la came du porte-stylo \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid stylo_H () \n    {\n      digitalWrite (broche_servo, HIGH); \/\/ allume la broche du servo\n      delay(250);\n      Servo_stylo.write(angle_stylo_H); \/\/ met le servo sur la position haute\n      delay(250);\n      digitalWrite (broche_servo, LOW); \/\/ coupe la broche du servo (economie)\n    }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ baisse la came du porte-stylo \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid stylo_B () \/\/ baisse la came du porte-stylo en haut\n    {\n      digitalWrite (broche_servo, HIGH); \/\/ allume la broche du servo\n      delay(250);\n      Servo_stylo.write(angle_stylo_B); \/\/ met le servo sur la position basse\n      delay(250);\n      digitalWrite (broche_servo, LOW); \/\/ coupe la broche du servo (economie)\n    }\n\n\n\/***************************************************************************\n *  deplacement avant arri\u00e8re\n * utilise la sous routine \"step\" pour calculer le nombre de pas \n***************************************************************************\/\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ avance de la distance d\u00e9finie en cm \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid avance (float distance) \n  {\n  int steps = step(distance); \/\/ affecte le nombre de pas \u00e0 steps\n\n  for(int step=0; step&lt;steps; step++) \/\/ boucle sur le nombre de pas moteurs \u00e0 effectuer\n    {\n    for(int mask=0; mask&lt;4; mask++)\n      {\n      for(int pin=0; pin&lt;4; pin++)\n        {\n        digitalWrite(broches_MoteurG&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ avance le moteur gauche d'un pas\n        digitalWrite(broches_MoteurD&#91;pin], levo&#91;mask]&#91;pin]); \/\/ avance le moteur droit d'un pas\n        }\n      delay(duree_delai);\n      } \n    }\n    fin();\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ recule de la distance d\u00e9finie en cm \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\nvoid recule (float distance) \/\/ recule de la distance d\u00e9finie en cm\n  {\n    int steps = step(distance);\n\n    for(int step=0; step&lt;steps; step++) \/\/ boucle sur le nombre de pas moteurs \u00e0 effectuer\n      {\n      for(int mask=0; mask&lt;4; mask++)\n        {\n        for(int pin=0; pin&lt;4; pin++)\n          {\n          digitalWrite(broches_MoteurG&#91;pin], levo&#91;mask]&#91;pin]); \/\/ recule le moteur gauche d'un pas\n          digitalWrite(broches_MoteurD&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ recule le moteur droit d'un pas\n          }\n        delay(duree_delai);\n        } \n      }\n      fin();\n  }\n  \n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/         sous routine \"step\"           \/\/\n\/\/\u00e9tablit le nombre de pas de d\u00e9placement\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\nint step(float distance) \/\/ retourne le nombre de pas pour r\u00e9aliser la distance\n  {\n    int steps = distance \/ AvanceParPas; \/\/ calcule le nombre de pas\n    if (steps==0) \/\/ permet les avances d'un pas en affectant 0\n    {\n      steps=1;\n    }\n  return steps; \/\/ retourne le nombre de pas \n  }\n\n\/***************************************************************************\n * rotation sur l'axe du stylo\n * utilise la sous routine \"stepR\" pour calculer le nombre de pas \n***************************************************************************\/\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ tourne sur la gauche d'un angle d\u00e9fini \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\n  void tournegauche (float angle)\n  {\n    \n    int steps = stepR(angle); \/\/ demande le calcul dun nombre de pas\n    for(int stepR=0; stepR&lt;steps; stepR++) \/\/ boucle sur le nombre de pas moteurs \u00e0 effectuer\n      {\n      for(int mask=0; mask&lt;4; mask++)\n        {\n        for(int pin=0; pin&lt;4; pin++)\n          {\n          digitalWrite(broches_MoteurG&#91;pin], levo&#91;mask]&#91;pin]); \/\/ recule le moteur gauche d'un pas\n          digitalWrite(broches_MoteurD&#91;pin], levo&#91;mask]&#91;pin]); \/\/ avance le moteur droit d'un pas\n          }\n        delay(duree_delai);\n        } \n      }\n    fin();\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ tourne sur la droite d'un angle d\u00e9fini \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\n   void tournedroite (float angle) \/\/ tourne sur la droite d'un angle d\u00e9fini\n    {\n   \n    int steps = stepR(angle); \/\/ demande le calcul dun nombre de pas\n \n    for(int stepR=0; stepR&lt;steps; stepR++) \/\/ boucle sur le nombre de pas moteurs \u00e0 effectuer\n      {\n      for(int mask=0; mask&lt;4; mask++)\n        {\n        for(int pin=0; pin&lt;4; pin++)\n          {\n          digitalWrite(broches_MoteurG&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ avance le moteur gauche d'un pas\n          digitalWrite(broches_MoteurD&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ recule le moteur droit d'un pas\n          }\n        delay(duree_delai);\n        } \n      }\n      fin();\n    }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/          sous routine \"stepR\"            \/\/\n\/\/\u00e9tablit le nombre de pas pour la rotation \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\nint stepR(float angle){\n  int stepsR = ((empattement * angle* 3.1415926)\/360)  * Paspartour \/ (dia_roue * 3.1415926); \/\/ Calcule le nombre de pas pour tourner d'un angle d\u00e9fini\n  if (stepsR==0) \/\/ permet les avances d'un pas en affectant 0\n  {\n    stepsR=1;\n  }\n  \n return stepsR; \/\/ retourne le nombre de pas\n}\n\n\/***************************************************************************\n * d\u00e9placement en 1\/4 de cercle de diam\u00e8tre d\u00e9fini\n * utilise les sous routine \"stepsext\" et \"stepint\" \n * pour calculer le nombre de pas pour chacune des roues\n***************************************************************************\/\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ 1\/4 de cercle  en avan\u00e7ant sur la droite \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid avantdroite (float dia_rot) \n  {\n\n    float steps_ext = stepsext(dia_rot); \/\/ demande le nombre de pas de la roue ext\u00e9rieure\n    float steps_int = stepsint(dia_rot); \/\/ demande le nombre de pas de la roue int\u00e9rieure\n    float ratio_init = steps_ext\/abs(steps_int); \/\/ calcule le ratio entre les pas ext et les pas int\n    int step=0; \/\/ affecte 0 \u00e0 step qui comptera les pas ext\u00e9rieurs\n    float ratio_dyn=0; \/\/ affecte 0 \u00e0 ratio dyn qui permettra de g\u00e9rer les avances diff\u00e9rentielle entre roues\n    float test_ratio = ratio_init-1; \/\/ calcule test_ratio qui d\u00e9clenchera l'avance de la roue int\u00e9reur quand le ratio sera correct\n\n    while( step&lt;steps_ext)\/\/ lance la boucle tant que la  roue ext\u00e9rieure n'aura pas finit le nombre de pas \n    {        \n      for(int mask=0; mask&lt;4; mask++)\n        {\n        for(int pin=0; pin&lt;4; pin++)\n          {\n          digitalWrite(broches_MoteurG&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ fait avancer la roue gauche (ext)\n          }\n          delay(duree_delai);\n        }\n        \n        ratio_dyn=ratio_dyn+1; \/\/ incr\u00e9mente le ratio dynamique\n        step++; \/\/ incr\u00e9mente le nombre de pas ext r\u00e9alis\u00e9s\n      \n        if (ratio_dyn>= test_ratio) \/\/ si le ratio est atteint moins un pas  \n          {  \n          for(int mask=0; mask&lt;4; mask++)\n            {\n            for(int pin=0; pin&lt;4; pin++)\n            {\n            digitalWrite(broches_MoteurG&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ fait avancer la roue gauche (ext)           \n            \n            if (steps_int&lt;=0) \/\/ si la roue int\u00e9rieure doit reculer (diam\u00e8tre du cercle &lt;empattement du robot)\n              {\n              digitalWrite(broches_MoteurD&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ fait reculer la roue droite (int)    \n              }\n              else\n              {\n              digitalWrite(broches_MoteurD&#91;pin], levo&#91;mask]&#91;pin]); \/\/ fait avancer la roue droite (int) \n              }            \n            }\n            \n            delay(duree_delai);\n            \n            }     \n          step++; \/\/ incr\u00e9mente le nombre de pas ext r\u00e9alis\u00e9s\n          ratio_dyn= ratio_dyn-test_ratio; \/\/ calcule le ratio dyn (conserve les d\u00e9cimales pour les incr\u00e9menter de nouveau)\n          } \n  \n      } \n\n      fin();\n    }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ 1\/4 de cercle  en avan\u00e7ant sur la gauche \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid avantgauche (float dia_rot) \n  {\n    \n    float steps_ext = stepsext(dia_rot); \/\/ demande le nombre de pas de la roue ext\u00e9rieure\n    float steps_int = stepsint(dia_rot); \/\/ demande le nombre de pas de la roue int\u00e9rieure\n    float ratio_init = steps_ext\/abs(steps_int); \/\/ calcule le ratio entre les pas ext et les pas int\n    int step=0; \/\/ affecte 0 \u00e0 step qui comptera les pas ext\u00e9rieurs\n    float ratio_dyn=0; \/\/ affecte 0 \u00e0 ratio dyn qui permettra de g\u00e9rer les avances diff\u00e9rentielle entre roues\n    float test_ratio = ratio_init-1; \/\/ calcule test_ratio qui d\u00e9clenchera l'avance de la roue int\u00e9reur quand le ratio sera correct\n\n    while( step&lt;steps_ext) \/\/ lance la boucle tant que la  roue ext\u00e9rieure n'aura pas finit le nombre de pas \n    {        \n      for(int mask=0; mask&lt;4; mask++)\n        {\n        for(int pin=0; pin&lt;4; pin++)\n          {\n          digitalWrite(broches_MoteurD&#91;pin], levo&#91;mask]&#91;pin]); \/\/ fait avancer la roue droite (ext)\n          }\n          delay(duree_delai);\n        }\n        \n        ratio_dyn=ratio_dyn+1; \/\/ incr\u00e9mente le ratio dynamique\n        step++; \/\/ incr\u00e9mente le nombre de pas ext r\u00e9alis\u00e9s\n      \n        if (ratio_dyn>= test_ratio) \/\/ si le ratio est atteint moins un pas    \n          {  \n          for(int mask=0; mask&lt;4; mask++)\n            {\n            for(int pin=0; pin&lt;4; pin++)\n            {\n            digitalWrite(broches_MoteurD&#91;pin], levo&#91;mask]&#91;pin]); \/\/ fait avancer la roue droite (ext)          \n            \n            if (steps_int&lt;=0) \/\/ si la roue int\u00e9rieure doit reculer (diam\u00e8tre du cercle &lt;empattement du robot)\n              {\n              digitalWrite(broches_MoteurG&#91;pin], levo&#91;mask]&#91;pin]); \/\/ fait reculer la roue gauche (int)  \n              }\n              else\n              {\n              digitalWrite(broches_MoteurG&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ fait avancer la roue droite (int) \n              }            \n            }\n            \n            delay(duree_delai);\n            \n            }     \n          step++; \/\/ incr\u00e9mente le nombre de pas ext r\u00e9alis\u00e9s\n          ratio_dyn= ratio_dyn-test_ratio; \/\/ calcule le ratio dyn (conserve les d\u00e9cimales pour les incr\u00e9menter de nouveau)\n          } \n  \n      } \n\n      fin();\n    }\n\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ 1\/4 de cercle  en reculant sur la droite \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\n  void arrieredroite (float dia_rot)   \/\/ trace un 1\/4 de cercle en reculant sur la droite  \n    {\n\n    float steps_ext = stepsext(dia_rot); \/\/ demande le nombre de pas de la roue ext\u00e9rieure\n    float steps_int = stepsint(dia_rot); \/\/ demande le nombre de pas de la roue int\u00e9rieure\n    float ratio_init = steps_ext\/abs(steps_int); \/\/ calcule le ratio entre les pas ext et les pas int\n    int step=0; \/\/ affecte 0 \u00e0 step qui comptera les pas ext\u00e9rieurs\n    float ratio_dyn=0; \/\/ affecte 0 \u00e0 ratio dyn qui permettra de g\u00e9rer les avances diff\u00e9rentielle entre roues\n    float test_ratio = ratio_init-1; \/\/ calcule test_ratio qui d\u00e9clenchera l'avance de la roue int\u00e9reur quand le ratio sera correct\n\n    while( step&lt;steps_ext) \/\/ lance la boucle tant que la  roue ext\u00e9rieure n'aura pas finit le nombre de pas \n    {        \n      for(int mask=0; mask&lt;4; mask++)\n        {\n        for(int pin=0; pin&lt;4; pin++)\n          {\n          digitalWrite(broches_MoteurD&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ fait reculer la roue droite (ext)\n          }\n          delay(duree_delai);\n        }\n        \n        ratio_dyn=ratio_dyn+1; \/\/ incr\u00e9mente le ratio dynamique\n        step++; \/\/ incr\u00e9mente le nombre de pas ext r\u00e9alis\u00e9s\n      \n        if (ratio_dyn>= test_ratio)  \/\/ si le ratio est atteint moins un pas  \n          {  \n          for(int mask=0; mask&lt;4; mask++)\n            {\n            for(int pin=0; pin&lt;4; pin++)\n            {\n            digitalWrite(broches_MoteurD&#91;pin], dextro&#91;mask]&#91;pin]);  \/\/ fait reculer la roue droite (ext)          \n            \n            if (steps_int&lt;=0) \/\/ si la roue int\u00e9rieure doit avancer (diam\u00e8tre du cercle &lt;empattement du robot)\n              {\n              digitalWrite(broches_MoteurG&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ fait avancer la roue gauche (int) \n              }\n              else\n              {\n              digitalWrite(broches_MoteurG&#91;pin], levo&#91;mask]&#91;pin]); \/\/ fait reculer la roue gauche (int)  \n              }            \n            }\n            \n            delay(duree_delai);\n            \n            }     \n          step++; \/\/ incr\u00e9mente le nombre de pas ext r\u00e9alis\u00e9s\n          ratio_dyn= ratio_dyn-test_ratio; \/\/ calcule le ratio dyn (conserve les d\u00e9cimales pour les incr\u00e9menter de nouveau)\n          } \n  \n      } \n\n      fin();\n    }\n\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ 1\/4 de cercle  en reculant sur la gauche \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\n  void arrieregauche (float dia_rot)\n  {\n    {\n    float steps_ext = stepsext(dia_rot); \/\/ demande le nombre de pas de la roue ext\u00e9rieure\n    float steps_int = stepsint(dia_rot); \/\/ demande le nombre de pas de la roue int\u00e9rieure\n    float ratio_init = steps_ext\/abs(steps_int); \/\/ calcule le ratio entre les pas ext et les pas int\n    int step=0; \/\/ affecte 0 \u00e0 step qui comptera les pas ext\u00e9rieurs\n    float ratio_dyn=0; \/\/ affecte 0 \u00e0 ratio dyn qui permettra de g\u00e9rer les avances diff\u00e9rentielle entre roues\n    float test_ratio = ratio_init-1; \/\/ calcule test_ratio qui d\u00e9clenchera l'avance de la roue int\u00e9reur quand le ratio sera correct\n\n    while( step&lt;steps_ext) \/\/ lance la boucle tant que la  roue ext\u00e9rieure n'aura pas finit le nombre de pas \n    {        \n      for(int mask=0; mask&lt;4; mask++)\n        {\n        for(int pin=0; pin&lt;4; pin++)\n          {\n          digitalWrite(broches_MoteurG&#91;pin], levo&#91;mask]&#91;pin]); \/\/ fait reculer la roue gauche (ext)\n          }\n          delay(duree_delai);\n        }\n        \n        ratio_dyn=ratio_dyn+1; \/\/ incr\u00e9mente le ratio dynamique\n        step++; \/\/ incr\u00e9mente le nombre de pas ext r\u00e9alis\u00e9s\n      \n        if (ratio_dyn>= test_ratio)  \/\/ si le ratio est atteint moins un pas  \n          {  \n          for(int mask=0; mask&lt;4; mask++)\n            {\n            for(int pin=0; pin&lt;4; pin++)\n            {\n            digitalWrite(broches_MoteurG&#91;pin], levo&#91;mask]&#91;pin]); \/\/ fait reculer la roue gauche (ext)            \n            \n            if (steps_int&lt;=0) \/\/ si la roue int\u00e9rieure doit reculer (diam\u00e8tre du cercle &lt;empattement du robot)\n              {\n              digitalWrite(broches_MoteurD&#91;pin], levo&#91;mask]&#91;pin]); \/\/ fait avancer la roue droite (int) \n              }\n              else\n              {\n              digitalWrite(broches_MoteurD&#91;pin], dextro&#91;mask]&#91;pin]); \/\/ fait reculer la roue droite (int)  \n              }            \n            }\n            \n            delay(duree_delai);\n            \n            }     \n          step++; \/\/ incr\u00e9mente le nombre de pas ext r\u00e9alis\u00e9s\n          ratio_dyn= ratio_dyn-test_ratio; \/\/ calcule le ratio dyn (conserve les d\u00e9cimales pour les incr\u00e9menter de nouveau)\n          } \n  \n      } \n\n      fin();\n    }\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/                      sous routine \"stepext\"                     \/\/\n\/\/\u00e9tablit le nombre de pas pour la rotation pour la roue exterieure\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nint stepsext(float dia_rot) \n  {\n    float perim_ext= (3.1415926 * ((dia_rot) + (empattement)))\/4; \/\/ calcule le p\u00e9rim\u00e8tre parcouru par la roue ext\u00e9rieure\n    int steps_ext = perim_ext\/AvanceParPas  ; \/\/ nombre de pas n\u00e9cessaires \n    return steps_ext;  \n  }\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/                      sous routine \"stepint\"                     \/\/\n\/\/\u00e9tablit le nombre de pas pour la rotation pour la roue exterieure\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nint stepsint(float dia_rot)  \n  {\n      float perim_int= (3.1415926 * ((dia_rot) - (empattement)))\/4; \/\/ calcule le p\u00e9rim\u00e8tre parcouru par la roue int\u00e9rieure\n      int steps_int = perim_int\/AvanceParPas  ; \/\/ nombre de pas n\u00e9cessaires attention la valeur est n\u00e9gative si empattement &lt; diam\u00e8tre\n      return steps_int; \n  }\n\n\n\/***************************************************************************\n * gestion du speaker\n***************************************************************************\/\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ Joue une m\u00e9lodie \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\nvoid melodie () \n{\n  int melody&#91;] =   \n    { \n    349,349,349,392,440,392,349,440,392,392,349, \/\/ Au clair de la lune\n    };\n  int duree&#91;] = \n    {\n    200,200,200,200,500,500,200,200,200,200,200, \/\/ dur\u00e9e des notes\n    };\n  for (int thisNote = 0; thisNote &lt; 11; thisNote++) \n    {\n    tone(broche_speaker, melody&#91;thisNote], duree&#91;thisNote]); \/\/ Joue la note\n    delay(duree&#91;thisNote]+100); \/\/ permet de s\u00e9parer les notes    \n    noTone(broche_speaker); \/\/ stoppe le son\n    }\n    speak = 1 ; \/\/ Met le flag boucle sonore \u00e0 1\n}\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ Joue un bip \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid bip () \n{\n    tone(broche_speaker, 600, 250); \/\/ Bip\n    delay(300); \/\/ permet de s\u00e9parer les notes    \n    noTone(broche_speaker); \/\/ stoppe le son\n    speak = 1 ; \/\/ Met le flag boucle sonore \u00e0 1\n}\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ Joue un bip grave \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid rale () \n{\n    tone(broche_speaker, 140, 800); \/\/ Bip grave\n    delay(1000); \/\/ permet de s\u00e9parer les notes    \n    noTone(broche_speaker); \/\/ stoppe le son\n    speak = 1 ; \/\/ Met le flag boucle sonore \u00e0 1\n}   \n\n\/***************************************************************************\n * gestion de la led multicolore\n***************************************************************************\/\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/allume en blanc\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid allume_blanc () \n  {\n  led_RGB.setBrightness(255); \/\/ luminosit\u00e9 max\n  led_RGB.begin(); \/\/d\u00e9marre l'allumage\n  led_RGB.setPixelColor(0, led_RGB.Color(255,255,255)); \/\/allume toutes les leds = blanc\n  led_RGB.show(); \/\/allume la led\n  fin();\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/allume en bleu \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid allume_bleu () \n  {\n  led_RGB.setBrightness(255); \/\/ luminosit\u00e9 max\n  led_RGB.begin(); \/\/d\u00e9marre l'allumage\n  led_RGB.setPixelColor(0, led_RGB.Color(0,0,255)); \/\/allume B = bleu\n  led_RGB.show(); \/\/allume la led\n  fin();\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/allume en vert \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid allume_vert () \n  {\n  led_RGB.setBrightness(255); \/\/ luminosit\u00e9 max\n  led_RGB.begin(); \/\/d\u00e9marre l'allumage\n  led_RGB.setPixelColor(0, led_RGB.Color(0,255,0)); \/\/allume G = vert\n  led_RGB.show(); \/\/allume la led\n  fin();\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/allume en rouge\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid allume_rouge () \n  {\n  led_RGB.setBrightness(255); \/\/ luminosit\u00e9 max\n  led_RGB.begin(); \/\/d\u00e9marre l'allumage\n  led_RGB.setPixelColor(0, led_RGB.Color(255,0,0)); \/\/allume R = rouge\n  led_RGB.show(); \/\/allume la led\n  fin();\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/allume en violet\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid allume_violet () \n  {\n  led_RGB.setBrightness(255); \/\/ luminosit\u00e9 max\n  led_RGB.begin(); \/\/d\u00e9marre l'allumage\n  led_RGB.setPixelColor(0, led_RGB.Color(255,0,255)); \/\/allume R+B = violet\n  led_RGB.show(); \/\/allume la led\n  fin();\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/allume en turquoise\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid allume_turquoise () \n  {\n  led_RGB.setBrightness(255); \/\/ luminosit\u00e9 max\n  led_RGB.begin(); \/\/d\u00e9marre l'allumage\n  led_RGB.setPixelColor(0, led_RGB.Color(0,255,255)); \/\/allume G+B = turquoise\n  led_RGB.show(); \/\/allume la led\n  fin();\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/allume en jaune\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid allume_jaune () \n  {\n  led_RGB.setBrightness(255); \/\/ luminosit\u00e9 max\n  led_RGB.begin(); \/\/d\u00e9marre l'allumage\n  led_RGB.setPixelColor(0, led_RGB.Color(125,125,0)); \/\/allume G+B = turquoise\n  led_RGB.show(); \/\/allume la led\n  fin();\n  }\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/eteind la led\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\nvoid eteins_led () \n  {\n  led_RGB.setBrightness(0);\n  led_RGB.begin();\n  led_RGB.setPixelColor(0, led_RGB.Color(0,0,0));\n  led_RGB.show();\n  fin();\n  }\n\n\/***************************************************************************\n * gestion de la fin de transmission\n***************************************************************************\/\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/Fin transmission\/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\n  void fin () \n  {\n    BTmySerial.println (\"@\"); \/\/ envoir un arobace \u00e0 la fin de la transmission\n    if (speak == 0) \/\/ v\u00e9rfie si on ne sort pas d'une boucle sonore\n      {\n      bip ();\n      }\n    speak = 0;\n  }\n\n\/***************************************************************************\n * programmes de test pour \u00e9talonner la Tortue\n * permet de corriger le diam\u00e8tre des roues (demi tour)\n * permet de corriger l'empattement (carr\u00e9)\n***************************************************************************\/\n\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ figure test carr\u00e9  \/\/\n\/\/ gestion des angles \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\n  void test_carre()\n  {\n    stylo_B();\n    avance(150);\n    tournegauche(90);\n    avance(150);\n    tournegauche(90);\n    avance(150);\n    tournegauche(90);\n    avance(150);\n    stylo_H();\n    bip();\n    bip();\n  }\n\n  \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\/\/ figure test carr\u00e9  \/\/\n\/\/ gestion des angles \/\/\n\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\n\n  void demi_tour()\n  {\n    stylo_B();\n    avance(300);\n    stylo_H();\n    tournegauche(180);\n    stylo_B();\n    avance(300);\n    stylo_H();\n    bip();\n    bip();\n  }\n\n\n\/***************************************************************************\n * configuration du BT\n***************************************************************************\/\nvoid BTConfig()\n{\t\t\n\tBTmySerial.begin(9600); \/\/ Ouvre le port s\u00e9rie \u00e0 900 Bauds\n\tBTmySerial.print(\"AT\"); \/\/ Ouvre le mode \u00e9criture\n\tdelay(400); \n\tBTmySerial.print(\"AT+DEFAULT\"); \/\/ Restaure la configuration d'usine\n\tdelay(2000); \n\tBTmySerial.print(\"AT+NAMETortue\"); \/\/ Nomme le BT Tortue\n\tdelay(400);\t\n  BTmySerial.print(\"AT+PIN1234\"); \/\/ d\u00e9finit le code PIN pour se connecter\n\tdelay(400);\n\tBTmySerial.print(\"AT+AUTH1\"); \/\/ protocole d'authentification\n  delay(400);    \n  BTmySerial.flush(); \/\/ Purge le buffer\n}<\/code><\/pre>\n\n\n\n<h5 class=\"wp-block-heading\">Et la suite&#8230;<\/h5>\n\n\n\n<p>Il faut encore finaliser le lecteur de carte en lui offrant la possibilit\u00e9 d&rsquo;enregistrer les cartes et rappeler les programmes et les sous-programmes. Une fois ce travail achev\u00e9, une page sera \u00e9videmment consacr\u00e9e au lecteur de carte qui me semble prometteur pour travailler la culture informatique.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Apr\u00e8s avoir expliqu\u00e9 comment les syst\u00e8mes \u00e9ducatifs ont pu assimiler les techniques num\u00e9riques invent\u00e9es par des personnalit\u00e9s du MIT comme Seymour PAPERT et Mitchel RESNICK, sans pour autant chercher \u00e0 s&rsquo;en accommoder, il me semble qu&rsquo;il est temps de remonter nos manches et (r\u00e9)explorer ces outils pour comprendre ce qu&rsquo;ils avaient de potentiellement r\u00e9volutionnaire (&#8230; [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"iawp_total_views":57,"footnotes":""},"categories":[1],"tags":[],"post_folder":[],"class_list":["post-1140","post","type-post","status-publish","format-standard","hentry","category-blog"],"_links":{"self":[{"href":"https:\/\/albooms.fr\/index.php?rest_route=\/wp\/v2\/posts\/1140","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/albooms.fr\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/albooms.fr\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/albooms.fr\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/albooms.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1140"}],"version-history":[{"count":8,"href":"https:\/\/albooms.fr\/index.php?rest_route=\/wp\/v2\/posts\/1140\/revisions"}],"predecessor-version":[{"id":1156,"href":"https:\/\/albooms.fr\/index.php?rest_route=\/wp\/v2\/posts\/1140\/revisions\/1156"}],"wp:attachment":[{"href":"https:\/\/albooms.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1140"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/albooms.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1140"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/albooms.fr\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1140"},{"taxonomy":"post_folder","embeddable":true,"href":"https:\/\/albooms.fr\/index.php?rest_route=%2Fwp%2Fv2%2Fpost_folder&post=1140"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}