Note pédagogique

•  Cette séance a pour but de programmer une carte Arduino en Scratch (mBlock), et non pas de découvrir l’ensemble des fonctionnalités de Scratch. Les tâches qui suivent se focalisent donc sur ces fonctionnalités spécifiques. Scratch permet de faire beaucoup d’autres choses, comme le montrent les autres projets présentés dans cet ouvrage !
•  Le professeur peut mettre en place, avant la présente séance, la séance « Découvrir Scratch » extraite de la séquence « programmation d’un jeu d’arcade : initiation à Scratch ». Le temps passé à s’initier aux bases de Scratch sera gagné plus tard, les élèves étant plus efficaces et autonomes. Bien entendu, cette séance d’initiation est inutile si les élèves ont déjà manipulé Scratch avant, même pour des projets très simples.

Avant-propos : préparer le matériel

Le bon déroulement de cette séance (et des suivantes) nécessite que le professeur ait préparé à l’avance le matériel qui sera utilisé par les élèves.

Carte Arduino

Arduino n’est pas un ordinateur miniature comme peut l’être un Raspberry Pi par exemple. Il n’embarque pas de système d’exploitation lui permettant d’être utilisé seul. Il s’agit simplement d’une carte équipée d’un micro-contrôleur capable de piloter des périphériques simples (capteurs, actionneurs), et programmable par l’utilisateur. La programmation doit se faire via un ordinateur.
Arduino possède de nombreuses qualités pour l’éducation :

•  faible coût ;
•  licence libre à la fois pour le matériel et le logiciel ;
•  grand nombre de capteurs/actionneurs disponibles sur le marché (eux-mêmes à coût très faible) et grand nombre de librairies de programmation ;
•  simplicité d’utilisation ;
•  compatibilité multi-plateforme (on peut le programmer à l’aide d’un PC Windows, d’un Mac…) ;
•  communauté très active, en France et dans le monde.

Arduino peut être utilisé de différentes façons :

•  matériel
  •  carte Arduino seule, sur laquelle on branche des capteurs/actionneurs directement. Il faut choisir soi-même les branchements, la polarité, la masse, en prenant bien garde à ajouter des résistances et à ne pas se tromper pour ne pas griller les composants !
  •  carte Arduino équipée d’un « Shield » (bouclier, en français… mais c’est le terme anglais qui est systématiquement employé), qui permet de simplifier considérablement les branchements des capteurs et actionneurs : ils sont branchés par une broche standardisée équipée de détrompeurs.
•  logiciel
  •  la carte se programme, de façon native, en langage C. Il s’agit d’un langage de programmation très polyvalent et extrêmement répandu. Cependant, c’est un langage textuel qui nécessite un apprentissage important (lexique, syntaxe…), moins adapté aux élèves de collège.
  •  La carte peut également se programmer à l’aide d’un langage graphique (programmation par « blocs ») comme Scratch, Blockly, Ardublock ou Snap. Nous conseillons Scratch (ou plutôt une de ses extensions appelée mBlock). Scratch est un environnement de programmation spécialement conçu pour l’éducation : très intuitif, gratuit, multiplateforme… il a de nombreuses qualités pour servir de base à l’apprentissage de la programmation [Blockly constitue une excellente alternative, surtout lorsqu’il s’agit de programmer des objets physiques (robots, cartes Arduino…). Voir à ce sujet le projet « Robotique avec Thymio ».].

Pour résumer, les différentes possibilités d’utilisation de la carte Arduino sont les suivantes.

NB : dans ce schéma, Scratch peut être remplacé par n’importe quel autre langage graphique (Ardublock, Blockly…) permettant de piloter une carte Arduino.

Il existe plusieurs variantes de la carte Arduino, et plusieurs « Shields » possibles. Notre séquence est basée sur l’utilisation de la carte Arduino Uno et du Shield Grove qui possède une grande quantité de capteurs et actionneurs compatibles.
Le projet peut être mené avec d’autres variantes de carte Arduino ou de Shields ou même de langages de programmation : le déroulement sera sensiblement le même, mais les captures d’écran et photos des montages seront différentes.

Le montage du Shield Grove sur la carte Arduino est très rapide et ne présente aucune difficulté. Cette opération peut être menée par les élèves. Cependant, nous conseillons au professeur de la réaliser en amont, ne serait-ce que pour vérifier le bon fonctionnement de l’ensemble (quitte, une fois la vérification faite, à démonter le système pour laisser les élèves le remonter).

Capteurs-actionneurs

Il existe des dizaines de capteurs ou actionneurs différents, pour des prix allant de quelques euros à quelques dizaines d’euros. Voici la liste du matériel nécessaire pour réaliser le projet tel qu’il est présenté dans les séances qui suivent [Le coût pour chaque groupe est estimé à une cinquantaine d’euros, auprès de distributeurs comme « technologie services » ou « go tronic ».] :

Logiciel mBlock

Le logiciel mBlock est une extension de Scratch conçue spécifiquement pour piloter une carte Arduino. Ce logiciel est gratuit et disponible pour plusieurs plateformes (Windows, Mac).
Attention : dans sa version de base, à l’heure où nous écrivons ces lignes, mBlock fonctionne avec Arduino, mais pas avec ses différents « Shields ». Certains fabricants ou distributeurs de matériel ont développé des versions de mBlock optimisées pour l’utilisation couplée de carte Arduino et du Shield Grove. « Technologie Services » propose un fichier d’installation comprenant à la fois le logiciel mBlock et son extension compatible, ainsi qu’un guide d’installation. Nous avons utilisé mBlock version 3.3.1 et l’extension « technologies services » version 1.2. L’ensemble est téléchargeable ici : http://tinyurl.com/domotique-lamap

Attention : l’installation et la configuration de mBlock (et de sa variante adaptée au Shield Grove) prennent un peu de temps, aussi il est indispensable que ces opérations aient été réalisées par le professeur avant la séance, sur chaque ordinateur susceptible d’être utilisé par les élèves. On trouve des tutoriels (PDF ou vidéos) très bien faits sur les sites web des distributeurs.

Présentation d’Arduino

Le professeur annonce aux élèves qu’ils vont désormais utiliser des composants électroniques permettant de réaliser la maquette de leur système domotique. Il explique le fonctionnement général :

•  Les capteurs et les actionneurs sont branchés sur une carte qui permet de les contrôler. Cette carte s’appelle Arduino.
•  La carte Arduino peut être programmée à l’aide d’un ordinateur, en utilisant l’environnement de programmation mBlock (si c’est bien le choix qui a été fait !).

Le professeur explique qu’avant de réaliser des montages complexes, la classe va avoir besoin de se familiariser avec ce matériel, et va donc commencer par des montages très simples. Petit à petit, les montages deviendront plus complexes, tout comme les programmes qui les piloteront.

Premier montage : brancher Arduino, le Shield Grove et une DEL (par groupes)

Le professeur peut, au choix, présenter le matériel à chaque groupe et leur demander d’identifier les différents éléments, ainsi que leurs rôles, ou bien distribuer la Fiche 2.
Le premier exercice consiste simplement à trouver un branchement qui permette à la DEL rouge de s’allumer.
Les élèves peuvent tâtonner pour trouver par eux-mêmes, dès lors que le professeur les a prévenus que les pattes de branchement du Shield Grove sont très fragiles et à manier avec précaution.

Carte Arduino, Shield Grove et DEL.

Le branchement est très simple :

• 1. Brancher le Shield Grove sur la carte Arduino (des détrompeurs empêchent de la brancher à l’envers)
• 2. Alimenter l’ensemble en branchant le câble à la pile 9V d’un coté, et à la carte Arduino de l’autre. Si les branchements sont corrects, 2 diodes vertes s’allument :  une sur le Shield Grove (en haut), et une sur la carte Arduino (en bas)
• 3. Insérer la DEL sur son socket : la silhouette du méplat est indiquée sur l’epoxy, pour éviter les erreurs de polarité.
  
• 4. Brancher le câble Grove sur le socket de la DEL d’un coté et sur le Shield de l’autre (là aussi, des détrompeurs évitent les erreurs). Tous les branchements disponibles ne correspondent pas à des sorties, et toutes les sorties ne sont pas alimentées par défaut : il faut donc tâtonner pour trouver l’emplacement correct sur le Shield Grove (un des emplacements marqués I2C ou UART, voire note ci-dessous).

Notes scientifiques :

•  Le Shield Grove possède 16 connecteurs 4 broches, sur lesquels on peut brancher de nombreux capteurs/actionneurs compatibles :
  •  4 connecteurs analogiques : A0, A1, A2 et A3
  •  4 connecteurs numériques (ou « digitaux ») : D2, D3, D4, D5, D6, D7 et D8
  •  4 interfaces I2C (Internal Integrated Circuit : standard de communication entre un microprocesseur et un circuit, particulièrement utilisé dans la domotique).
  •  1 interface UART (Universal Asynchronous Receiver Transmitter : interface entre un microprocesseur et un port série)
•  Par ailleurs, le Shield Grove possède une connectique autorisant le branchement d’un second Shield Grove par-dessus (ce qui peut être utile si l’on est limité par les 16 connecteurs du Shield).
•  Les détails de fonctionnement de la carte Arduino et de son Shield Grove n’ont pas besoin d’être connus des élèves, tout comme la signification des différents standards de communication.
   

Note pédagogique :
 Si les élèves n’ont jamais manipulé de DEL avant ce projet, il peut être utile de consacrer quelques minutes à réaliser un branchement simple (sans carte Arduino), consistant à allumer une DEL à l’aide d’une pile. Ainsi, la carte Arduino apparaitra moins comme une « boite noire ».

Second montage : faire clignoter la DEL (programmer la carte Arduino via mBlock)

Le professeur demande aux élèves comment faire pour décider si la DEL doit s’allumer ou non. Le précédent montage ne laisse pas le choix (selon comment on l’a branchée, la DEL est soit toujours allumée, soit toujours éteinte). La solution est : programmer la carte Arduino pour lui dire d’allumer et d’éteindre la DEL successivement.

Branchement et découverte de Scratch/mBlock

L’enseignant explique aux élèves que Scratch est un langage de programmation conçu spécifiquement pour apprendre à programmer, et que mBlock est une extension de Scratch conçue pour piloter des périphériques comme une carte Arduino.
Lorsque l’on ouvre le logiciel, il y a un lutin à l’écran (un panda). Tout comme dans Scratch, on peut ajouter autant de lutins qu’on le souhaite, et programmer chacun d’entre eux.

Les élèves branchent leurs cartes Arduino aux ordinateurs (via leurs câbles USB) et lancent le programme mBlock. Ils s’aident pour cela de la Fiche 3.

Note scientifique
Selon la configuration matérielle de l’ordinateur, il se peut que le port USB délivre un courant suffisant pour alimenter la carte Arduino, le Shield Grove et la DEL. Dans ce cas, l’alimentation externe 9V n’est plus nécessaire.

Interface de mBlock.
Le programme en exemple ici permet de faire clignoter une DEL branchée sur le port D8 du Shield Grove.

L’enseignant présente rapidement l’interface de Scratch/mBlock, qui comprend :

•  Une « scène » : c’est là que se déroule le programme. Dans notre cas particulier (pilotage de la carte Arduino), le résultat du programme se verra davantage sur la carte elle-même que sur la scène.
•  Une zone « lutins » : les lutins sont les personnages ou les objets qui seront manipulés dans le programme (ils peuvent se déplacer, changer de forme, parler, interagir avec les autres lutins…). Là encore, dans notre cas particulier, on se servira peu des lutins. En prolongement de ce projet, on peut néanmoins réaliser une modélisation du logement dans mBlock, auquel cas la scène et les lutins représenteront le logement, et chacun des capteurs et actionneurs.
•  Un onglet « script » qui permet d’accéder à :
  •  Une palette d’instructions (colonne centrale, à droite de la scène). C’est ici que l’on trouve les instructions (ou « blocs ») à utiliser dans notre programme. Il y a de nombreuses instructions, regroupées par couleur (exemple : tout ce qui concerne le mouvement du lutin est dans un onglet bleu foncé, tout ce qui concerne son apparence est dans un onglet violet, etc.). L’onglet qui nous intéresse est l’onglet « pilotage », présent dans mBlock mais pas dans Scratch (cf. détails ci-dessous).
  •  Une zone « programme », à droite de la palette d’instructions. C’est ici que l’on écrit le programme, tout simplement en prenant des instructions depuis la palette et en les faisant glisser dans cette zone.

Le professeur réalise une rapide démonstration. Par exemple, pour demander au panda de se déplacer de 10 pas, il suffit de faire glisser l’instruction « avancer de 10 » depuis la palette d’instructions vers la zone du programme. Si l’on clique ensuite sur cette inscription, on remarque que le panda avance bien de 10 pas (1 pas = 1 pixel de l’écran).
Si l’on souhaite avancer de 20 pas, il suffit de changer « 10 » en « 20 » en cliquant dans la zone dédiée. Si maintenant on souhaite que le panda avance de 20 pas, puis dise « Bonjour », il suffit de coller la nouvelle instruction à la fin du programme. L’instruction « dire bonjour » n’existe pas, mais il y a une instruction « dire Hello » dans la catégorie « apparence » de la palette d’instructions. Il suffit de prendre cette instruction puis de remplacer le texte « Hello » en « Bonjour » en cliquant sur ce texte. Écrire un programme se fait simplement en emboitant des instructions entre elles.
Si maintenant on veut que le panda fasse cela à chaque fois que l’on clique sur le drapeau vert (en haut à droite de la scène, le drapeau vert permet de lancer le programme), alors il faut rajouter l’instruction « Quand drapeau vert pressé » à chercher dans la catégorie « événements » des instructions. Cela donne :
Finalement, l’enseignant montre comment supprimer une instruction (ou tout un bloc d’instructions) : il suffit de faire glisser cette instruction (ou ce bloc) depuis la zone du programme vers la palette des instructions.

Ici, la palette d’instructions qui nous intéresse est la palette vert foncé appelée  « pilotage ». C’est elle qui contient toutes les instructions permettant de piloter la carte Arduino et son Shield Grove.

Notes scientifiques

•  Il existe 2 modes permettant de piloter une carte Arduino via mBlock. Le mode connecté et le mode déconnecté. Le mode connecté nécessite que la carte soit branchée physiquement à l’ordinateur, tout le temps. Le mode déconnecté permet (une fois que l’on a transféré le programme sur la carte) de débrancher la carte Arduino de l’ordinateur : la carte est alors autonome (penser, dans ce cas, à lui rajouter son alimentation !).
•  Dans un premier temps, nous utiliserons le mode « connecté ».

Connecter la carte Arduino

La Fiche 3 explique comment connecter la carte Arduino à mBlock.

Allumer et éteindre la DEL depuis mBlock

Le professeur explique que les ports I2C et UART (utilisés précédemment) ne sont pas pilotables depuis mBlock. Il faut donc utiliser les ports A0…A3 ou D2…D8.

•  Les ports analogiques A0…A3 ne sont utilisables qu’en entrée (on peut lire des valeurs, mais on ne peut pas agir sur le capteur via ces ports).
•  Les ports numériques (ou digitaux) D2…D8 sont utilisables à la fois en entrée et en sortie. C’est sur l’un deux que l’on va brancher notre DEL, puisqu’on souhaite modifier son état.

Les élèves branchent donc leur DEL sur l’un des ports D2 à D8.

Le professeur montre le principe de la programmation mBlock en faisant une petite démonstration : il fait glisser la commande  dans la zone de programme. Il remplace la valeur « D2 » par celle correspondant au port sur lequel la DEL est branchée, et personnalise le message en choisissant « DEL rouge » (ce message n’est pas interprété par le programme, il sert à faciliter la lecture du programme par l’utilisateur).
En cliquant, ensuite, sur cette instruction, on remarque que la DEL s’allume. Si on remplace, dans l’instruction, la valeur « haut » par « bas », et qu’on reclique sur le block, alors la DEL s’éteint.

Les élèves répètent cette manipulation afin de se familiariser avec l’interface et les commandes.

Faire clignoter la DEL depuis mBlock

Le professeur demande aux élèves comment faire pour que la DEL clignote. En cas de besoin, il peut les inciter à expliciter l’algorithme avant de chercher à le programmer (c’est, en général, une très bonne habitude !).

L’algorithme s’exprime simplement de la façon suivante :  Répéter sans arrêt  Allumer la DEL  Attendre 1 seconde (évidemment, cette valeur est arbitraire !)  Eteindre la DEL  Attendre 1 seconde

Le professeur laisse les élèves tâtonner pour programmer cet algorithme à l’aide des instructions mBlock. En cas de difficulté, il peut leur indiquer que les structures de contrôles (pauses, boucles…) se trouvent dans la palette jaune.

Programme mBlock permettant de faire clignoter la DEL branchée sur la carte Arduino.

Bilan et conclusion

Un bilan s’impose car les élèves ont abordé beaucoup de notions nouvelles au cours de cette séance. La classe revient collectivement sur ce qui a été appris :

•  Arduino est une carte électronique permettant de piloter des capteurs et des actionneurs. Cette carte a besoin d’une alimentation électrique (9 V).
•  Le Shield Grove permet de faciliter les branchements sur la carte Arduino.
•  La carte Arduino peut être programmée à l’aide d’un ordinateur, par exemple en utilisant l’environnement de programmation mBlock.
•  mBlock permet de construire des programmes en assemblant des blocs d’instructions.

La classe synthétise également les commandes mBlocks qui sont désormais connues de tous :

•  Quand drapeau vert est pressé
•  Répéter indéfiniment
•  Attendre… secondes
•  Mettre … sur la broche … à …

Comme lors des séances précédentes, les élèves archivent les notes et photos qu’ils ont prises dans le but de préparer la restitution finale.