Construire les trois points du triangle est aisé puisqu’il suffit de cliquer sur leur emplacement souhaité.

Après avoir effectué un clic droit sur le point B, un menu contextuel apparaît. Il permet notamment de :

• créer les deux segments partant de B (BA et BM) : il suffit de cliquer sur l’icône segment, sans relâcher le clic avant que la souris soit positionnée sur le point à relier (A ou M).
• créer le milieu du segment BA : il suffit de cliquer sur l’icône segment, sans relâcher le clic avant que la souris soit positionnée sur le point A.
• renommer le point (par défaut, les points sont nommés P1, P2…) et de faire afficher son nom sur la figure : il suffit de cliquer sur l’icône en forme de roue dentée, qui fait apparaître une fenêtre à compléter ; pour fermer cette fenêtre, il faut passer par le tableau de bord situé en bas dans lequel il y a un bouton interrupteur lui aussi en forme de roue dentée.

La meilleure façon de comprendre tout ça est de l’expérimenter, ce qui entraînera inévitablement quelques tâtonnements au départ et des objets géométriques (points, segments) créés involontairement [3]. Par ailleurs, comme je l’ai mis en évidence sur la copie d’écran ci-dessus, il arrive fréquemment que les menus contextuels n’apparaissent plus car des manipulations ont fait quitter le mode « création » (mode par défaut de DGPad) : il est donc fondamental de connaître la parade indiquée sur la copie d’écran (cliquer sur la flèche à gauche du tableau de bord).

Le cercle de diamètre AB peut facilement être obtenu à partir du menu contextuel du milieu du segment AB : il suffit de cliquer sur l’icône de création d’un cercle (celle où il y a un point sur le pourtour), sans relâcher le clic avant que la souris soit positionnée sur le point à relier (A ou B).

La construction de l’objet DGPad mesurant l’angle AMB est moins simple. Elle peut être effectuée à partir du menu contextuel du point B (ce que je vais supposer dans mes explications) ou à partir du menu contextuel du point A.

L’icône en forme de quadrilatère, qui permet de créer un polygone, fonctionne sur le même principe : on la sélectionne sans relâcher la souris jusqu’à atteindre le second point, ce qui fait apparaître une nouvelle icône qu’il faut sélectionner sans relâcher la souris jusqu’à atteindre le troisième point, ce apparaître une nouvelle icône qu’il faut sélectionner sans relâcher la souris jusqu’à atteindre le quatrième point… Le processus s’interrompt quand on revient sur le point de départ : pour un triangle, il faut donc sélectionner le point de départ comme quatrième point.

Dans DGPad, tout point peut être associé à une tortue : il suffit de cliquer sur l’icône en forme de puzzle dans la palette contextuelle associée à ce point (ici M) pour accéder à l’environnement de programmation par blocs de sa tortue.

Les trois premiers blocs (« rejoindre le point ») permettent de relier les 3 points du triangle, avant que le bloc conditionnel fixe une couleur dépendant de la mesure en degrés de l’angle AMB.

Les effets d’une manipulation de bloc (ajout, modification ou suppression) sont immédiatement perceptibles, ce qui facilite la mise au point du programme. Ensuite, lorsque l’éditeur Blockly sera refermé, son code sera exécuté chaque fois qu’un point du triangle sera déplacé : donc, en déplaçant le point M, on verra sa couleur évoluer en fonction de la mesure de l’angle AMB.

Ce programme Blockly peut être réalisé avant ou après les diverses constructions géométriques (milieu du segment AB, cercle de diamètre AB, angle AMB), peu importe. Et à tout moment, on peut retourner dans l’éditeur Blockly du point M et modifier son code.

Avant d’entrer dans le vif du sujet, je tiens à signaler que ce complément n’est pas nécessaire à la lecture de la seconde partie de l’article consacrée aux activités pédagogiques de l’IREM Paris-Nord.

Dans un article intitulé « Comment promouvoir l’algorithmique dans un contexte géométrique » (http://revue.sesamath.net/spip.php?article1080), j’ai présenté un environnement de programmation par blocs (externe à DGPad) pouvant faciliter la création de figures DGPad si on ne maîtrise pas le logiciel (en particulier son outil « Calculatrice / Expressions » [4]). Cet environnement (nommé SofusGeo) est accessible depuis mes pages professionnelles consacrées à Blockly (voir lien) ou celles de l’IREM de la Réunion (voir lien).

Après avoir programmé ce code Blockly que je vais commenter brièvement, il suffit de cliquer sur le bouton « Exécuter » de SofusGeo pour basculer dans DGPad et obtenir la figure DGPad ci-dessus. On constate alors qu’il y a 3 informations (en rouge) la complétant. Elles résultent des 3 derniers blocs (2 blocs « expression » et un bloc « curseur ») :

• le premier bloc « expression » affiche le périmètre du triangle, calculé en sommant la longueur de chaque segment ( d(A,B) + d(A,M) + d(B,M) ) ; la valeur du périmètre est précédée d’un message (« périmètre du triangle : ») dont la position d’affichage est indiquée dans les attributs « x » et « y » du bloc.
• le second bloc « expression » affiche l’aire du triangle, en indiquant son nom (T) dans son champ valeur ; le triangle a été préalablement créé par le bloc « Triangle ».
• le bloc « curseur » crée un curseur, initialisé à 80, qu’on pourra faire varier entre les valeurs 0 et 100.

Une fois que le programme par blocs a été exécuté, il reste à faire plusieurs opérations dans l’environnement DGPad :

• compléter la figure géométrique (milieu du segment AB, cercle de diamètre AB…) à partir du menu contextuel des points.
• utiliser l’environnement Blockly associé au point M pour colorier le triangle en fonction de la valeur de l’angle AMB et, nouveauté par rapport à la section précédente, fixer une opacité dépendant de la valeur du curseur « opa ».

Le programme final peut être testé en cliquant ici.

Pour démarrer l’activité, il faut cliquer sur un lien (tester) qui ouvre DGPad et montre la figure à reproduire. A la droite de cette figure, six autres points (A0, A1 … A5) sont fournis : ils correspondent aux sommets de l’hexagone dans lequel il faut reproduire de nid d’abeilles avec des manipulations géométriques basiques (création de segments et de droites, puis de points d’intersection).

Sur la copie d’écran ci-dessus, on peut voir quelques manipulations que j’ai ensuite effectuées. Elles aboutissent à la création du point rouge (intersection [5] des segments A0A3 et A2A4) et des deux points bleus. En effectuant des manipulations similaires avec d’autres sommets, on peut ainsi créer 6*3 points (6 points rouges et 12 points bleus) :

Il reste encore pas mal de travail à réaliser, comme le montre la copie d’écran ci-dessus, mais cela ne demande plus que de la persévérance : en effet, la principale difficulté de l’activité (trouver un procédé permettant de couper en trois [6] les segments de l’hexagone englobant) a déjà été résolue.

Une alternative à cette activité un peu fastidieuse est de programmer la figure avec une tortue : on commence alors par créer manuellement deux points A et B correspondant à un côté du petit hexagone blanc central, puis on fait de la programmation par blocs avec la tortue du point A.

Tout comme pour le nid d’abeilles, les 6 sommets du grand hexagone (A0, A1 … A5) sont fournis au démarrage de l’activité (tester). Un petit cercle intérieur est également donné, ce qui permet de construire les points du petit hexagone (B0, B1 … B5) comme intersection avec les diagonales du grand hexagone (A0A3, A1A4, A2A5).

Il reste 2 points à construire pour chacun des 6 quadrilatères (rhomboïdes), ce qui ne pose aucune difficulté particulière.

Contrairement à l’exemple précédent (nid d’abeilles), aucune automatisation en programmation par blocs n’est possible pour obtenir la figure : en effet, les blocs de DGPad ne permettent pas de créer d’objets (points, segments, droites...) dans l’espace dynamique de DGPad. Je me tournerai donc vers MathémaBlocs, une « surcouche » de DGPad [1].

MathémaBlocs possède notamment une tortue qui, contrairement à celle de DGPad, ne se contente pas de faire des dessins, mais crée également des points lorsqu’elle se déplace. Cette caractéristique peut être utilisée pour obtenir les points des deux hexagones et les mettre dans deux listes (A pour le grand hexagone et B pour le petit hexagone).

Le programme ci-dessus commence par construire 3 points : C (centre de la figure), A0 (un point du grand hexagone) et B0 (un point du petit hexagone, situé sur le segment CA0). Ensuite, la tortue du point A0 construit les 5 autres points du grand hexagone : ces 6 points, qui correspondent à la trace de la tortue, sont à la fin récupérés par le bloc « liste des points de la tortue du point A0 » et mis dans la liste A. Enfin, la tortue du point B0 procède de façon analogue pour le petit hexagone.

Les listes A et B vont permettre, avec une boucle, de construire les 6 rhomboïdes. Mais pour une utilisation au collège, je préconise d’en rester là pour la programmation par blocs et de terminer l’activité avec des manipulations DGPad. On peut éventuellement fournir aux élèves le code à trous ci-dessous et leur demander de le compléter pour construire le quadrilatère passant par A0 et B0 :

Pour les lecteurs (et pas leurs élèves a priori), je poursuis l’automatisation en faisant un raisonnement modulo 6 dans une boucle construisant les 6 rhomboïdes :

En essayant diverses valeurs dans le bloc positionnant le point B0 sur le segment CA0, on se rend compte qu’il y a un changement d’aspect quand B0 est au tiers du segment :

Plutôt que de changer la valeur dans le bloc et de réexécuter le programme, on peut être tenté de déplacer B0 puisque c’est un point mobile de la figure DGPad. Hélas, ça ne marche pas : la figure est bien dynamique, mais n’évolue pas comme espéré. La méthode de construction des points par les tortues de MathémaBlocs serait à améliorer, mais c’est plus facile à dire qu’à faire...

Cette activité (tester) permet de travailler sur les cercles et, nouveauté, sur les arcs de cercles qui sont un peu plus difficiles à construire. Au départ, 4 points sont fournis : un point A et 3 points d’un carré de centre A (B0, B1 et B2).

Sur la figure ci-dessus, on peut voir que j’ai ensuite créé deux cercles passant par B1 et que je m’apprête à définir le second point d’intersection de ces cercles (B3). Cela permet alors de construire le cercle de centre B3 passant par B2 (et B0) avec le menu contextuel de B3, puis de définir deux nouveaux points (I2 et I0) comme intersection avec les deux autres cercles (en pointillés sur la figure ci-dessous) :

Il reste encore 5 arcs de cercle à dessiner. Voici comment procéder, à partir du menu contextuel du point B0, pour créer celui passant par les points B0, B1 et B2 :

Les arcs de cercle B1I2B3 et B1I0B3 peuvent être obtenus de façon similaire. Pour dessiner les 2 derniers (arc de centre B3 passant par I2 et B2, arc de centre B3 passant par I0 et B0), il faut d’abord créer un troisième point (K2 pour le premier arc, K0 pour le second) : il suffit de cliquer sur le cercle de centre B3 passant par I2 et B2 (respectivement I0 et B0), puis de sélectionner l’icône en forme de point qui apparaît alors.

Je trouve cette activité excellente avec un vrai compas et une vraie règle, mais pas simple à mettre en œuvre avec des manipulations DGPad. Peut-on faire une activité plus convaincante en programmation par blocs en recourant à MathémaBlocs ? La réponse est oui, à condition de fournir des blocs adaptés, par exemple :

• un bloc construisant un cercle en pointillés à partir de son centre et d’un point du pourtour.
• un bloc construisant un arc de cercle à partir de trois points.

Ces blocs n’existent pas, mais il est possible de les créer pour les fournir aux élèves, comme je l’ai expliqué dans « Activités ludiques en programmation par blocs avec un logiciel de mathématiques ». Cela passe par l’utilisation d’un outil de DGPad que je n’ai pas présenté (enregistreur de macros) et d’un bouton de l’environnement Blockly de MathémaBlocs. Comme cela nécessite une certaine expertise, je fournis dans la conclusion de l’article un lien permettant de démarrer l’activité avec un programme initial à compléter :

Le point B3, qui a pour coordonnées (0, taille) peut être construit directement ainsi, mais j’ai préféré rester dans l’optique de l’activité initiale où il est créé comme intersection de deux cercles.

L’étape suivante est de construire le cercle de centre B3 passant par B2 (et B0), puis de définir deux nouveaux points (I2 et I0) comme intersection avec les deux autres cercles. Des expérimentations sur l’ordre des 2 paramètres des blocs « intersection » sont nécessaires pour obtenir les points d’intersection souhaités, ce qui permet d’aboutir au code suivant :

Trois des cinq arcs de cercle peuvent facilement être obtenus à partir du bloc « macro_arc » :

Pour les deux derniers arcs, il faut d’abord placer deux points (K0 et K2) sur le cercle de centre B3 avec le bloc « Point sur l’objet », dont l’attribut « position » est à exprimer en radians.