Programmer un chronomètre fonctionnel est un projet en apparence modeste, mais qui recèle en réalité plusieurs subtilités techniques très instructives pour des élèves de collège : la gestion précise du temps, la conversion entre secondes et minutes, et le contrôle du démarrage et de l'arrêt d'un compteur. C'est aussi un projet extrêmement réutilisable, que ce soit pour chronométrer une partie de jeu, mesurer le temps de réaction d'un joueur, ou même simuler le fonctionnement d'un système automatisé réel comme un four à minuterie. Ce tutoriel détaille pas à pas la construction d'un chronomètre complet dans Scratch, depuis la version la plus simple jusqu'à des fonctionnalités avancées comme la pause et la remise à zéro.
Étape 1 : créer la variable qui va stocker le temps écoulé
Tout chronomètre repose sur une variable numérique qui va stocker le temps écoulé, généralement exprimé en secondes pour simplifier les calculs. Il faut donc commencer par créer une variable nommée par exemple « temps », dans la catégorie orange foncé « Variables » de Scratch. Il est important, dès cette étape, de réfléchir à la portée de cette variable : si le chronomètre doit être utilisé par un seul lutin, une variable « pour ce lutin uniquement » suffit, mais si plusieurs éléments du projet doivent consulter ou afficher cette valeur, une variable « pour tous les lutins » sera préférable.
Une fois la variable créée, elle apparaît automatiquement affichée sur la scène sous forme de petit compteur, ce qui est pratique pour les premiers tests mais que l'on masquera généralement par la suite au profit d'un affichage plus soigné, intégré directement dans le décor ou le costume d'un lutin dédié.
Étape 2 : incrémenter la variable seconde par seconde
Le cœur technique du chronomètre repose sur une boucle qui incrémente la variable temps à intervalles réguliers. Le script de base associe un bloc « répéter indéfiniment » contenant deux instructions : un bloc « attendre 1 seconde », suivi d'un bloc « ajouter 1 à temps ». Ce script simple, une fois lancé, incrémente fidèlement la variable temps d'une unité chaque seconde, produisant ainsi la base d'un chronomètre fonctionnel.
Il est pédagogiquement intéressant de faire observer aux élèves une variante moins précise de ce script, en remplaçant le bloc « attendre 1 seconde » par un bloc vide sans temporisation : le programme s'exécute alors si rapidement que la variable temps augmente de manière quasi instantanée, bien plus vite qu'une vraie seconde. Cette expérimentation permet de bien faire comprendre le rôle indispensable du bloc d'attente dans la synchronisation du programme avec le temps réel, une notion qui n'est pas toujours intuitive pour un élève découvrant la programmation.
Étape 3 : convertir les secondes en minutes et secondes
Un chronomètre affichant uniquement un nombre brut de secondes devient rapidement peu lisible au-delà de la première minute. Il est donc utile d'ajouter une conversion pour afficher le temps sous la forme classique « minutes:secondes ». Cette conversion mobilise des opérateurs mathématiques un peu plus avancés que ceux utilisés jusque-là : le nombre de minutes s'obtient en calculant la division entière de la variable temps par 60, à l'aide du bloc opérateur « arrondi vers le bas » combiné à une division, tandis que le nombre de secondes restantes s'obtient grâce à l'opérateur modulo, disponible dans Scratch sous la forme d'un bloc dédié qui renvoie le reste d'une division.
Concrètement, le script de conversion crée deux nouvelles variables, « minutes » et « secondes_restantes », calculées à partir de la variable temps à chaque affichage : minutes reçoit le résultat de « temps divisé par 60 arrondi vers le bas », et secondes_restantes reçoit le résultat de l'opérateur modulo entre temps et 60. Le bloc « dire » ou un costume de type afficheur numérique combine ensuite ces deux valeurs, éventuellement avec un zéro ajouté devant les secondes inférieures à 10 pour respecter la convention d'affichage habituelle (par exemple « 2:05 » plutôt que « 2:5 »).
Étape 4 : ajouter les fonctions démarrer, mettre en pause et réinitialiser
Un chronomètre pleinement fonctionnel doit permettre à l'utilisateur de contrôler son déroulement, et pas seulement de le regarder défiler passivement depuis le lancement du programme. Trois boutons, matérialisés par des lutins cliquables ou par des touches du clavier associées à des événements, permettent d'ajouter cette interactivité : un bouton « démarrer », qui lance la boucle d'incrémentation ; un bouton « pause », qui interrompt temporairement cette boucle sans réinitialiser la variable temps ; et un bouton « réinitialiser », qui remet la variable temps à zéro.
La gestion de la pause constitue la principale difficulté technique de cette étape, car Scratch ne propose pas nativement de bloc « mettre en pause un script ». La solution la plus couramment enseignée consiste à utiliser une variable booléenne supplémentaire, par exemple nommée « en_marche », qui vaut 1 lorsque le chronomètre doit tourner et 0 lorsqu'il doit être suspendu. La boucle d'incrémentation est alors conditionnée par cette variable, à l'aide d'un bloc « si en_marche = 1, alors » englobant l'instruction d'ajout de temps, ce qui permet de suspendre effectivement la progression du chronomètre sans jamais interrompre la boucle elle-même.
Étape 5 : exploiter le chronomètre dans un autre projet
Une fois maîtrisé isolément, ce chronomètre devient un composant réutilisable dans de très nombreux autres projets Scratch travaillés au collège. Il peut par exemple être intégré au jeu de labyrinthe présenté dans un précédent tutoriel, pour chronométrer le temps mis par le joueur à atteindre l'arrivée, ou au quiz interactif, pour ajouter une contrainte de temps limite à chaque question, ce qui renforce l'aspect ludique et le niveau de défi du projet. Cette réutilisation d'un même composant technique dans plusieurs contextes différents illustre un principe important de la programmation : plutôt que de tout reconstruire à chaque nouveau projet, il est souvent plus efficace de réutiliser et d'adapter des briques déjà maîtrisées.
Pour les élèves de 3e souhaitant aller plus loin, ce projet de chronomètre logiciel peut également servir de point de départ à une comparaison avec un chronomètre matériel réalisé avec une carte micro:bit ou Arduino, où la même logique de comptage du temps s'appuie cette fois sur une horloge interne du microcontrôleur plutôt que sur le bloc « attendre » de Scratch, ce qui permet d'aborder la notion de temporisation dans un contexte matériel réel.
Prolonger le projet vers une minuterie sonore
Pour donner un usage encore plus concret à ce chronomètre, il est intéressant de le transformer en minuterie déclenchant une alerte sonore une fois une durée définie atteinte, à la manière d'un minuteur de cuisine. Cette variante reprend l'essentiel du script déjà construit, mais ajoute une condition supplémentaire, testée à chaque tour de la boucle d'incrémentation : « si temps = durée_choisie, alors jouer le son alarme et mettre en_marche à 0 ». Cette dernière instruction, qui remet la variable de contrôle à zéro, arrête automatiquement la progression du chronomètre une fois l'alerte déclenchée, évitant qu'il continue indéfiniment à compter après avoir atteint son objectif.
Cette variante offre également l'occasion d'introduire le bloc « demander… et attendre » pour permettre à l'utilisateur de saisir lui-même la durée souhaitée avant de démarrer la minuterie, ce qui réinvestit directement les compétences travaillées dans le projet de quiz interactif présenté par ailleurs. Cette réutilisation croisée de compétences entre différents projets Scratch illustre bien l'intérêt d'une progression pédagogique cohérente sur l'ensemble de l'année, où chaque nouveau projet s'appuie sur des briques déjà maîtrisées plutôt que de repartir systématiquement de zéro.
Conclusion
Le projet de chronomètre, bien que modeste en apparence, constitue un excellent support pour travailler en profondeur la gestion du temps en programmation, les opérateurs mathématiques comme la division entière et le modulo, ainsi que la gestion d'états à travers une variable booléenne pour la fonction de pause. Une fois construit et maîtrisé, ce composant devient un outil réutilisable dans de nombreux autres projets Scratch, du jeu vidéo au quiz interactif, ce qui en fait un investissement pédagogique particulièrement rentable pour la suite de l'année.
Pour aller plus loin
Ce chronomètre repose entièrement sur les variables : si besoin, revois les exercices corrigés sur les variables et les exercices sur les boucles. Pour le réutiliser, intègre-le au jeu de labyrinthe ou ajoute un temps limite à ton quiz interactif Scratch.
La temporisation est aussi au cœur des systèmes automatisés réels : le TP porte de garage automatique avec micro:bit et les 20 projets micro:bit avec mBlock permettent de passer du chronomètre à l’écran à un objet qui réagit vraiment.
FAQ : questions fréquentes sur le chronomètre en Scratch
1. Pourquoi mon chronomètre avance-t-il plus vite qu'une vraie seconde ?
Cela signifie très probablement que le bloc « attendre 1 seconde » a été oublié ou mal placé dans la boucle d'incrémentation, ce qui fait avancer la variable temps à chaque passage de boucle sans aucune synchronisation avec le temps réel.
2. Comment afficher un zéro devant les secondes inférieures à 10 ?
Il faut utiliser une condition qui teste si la variable secondes_restantes est inférieure à 10, et dans ce cas, concaténer un zéro devant sa valeur grâce au bloc opérateur « joindre », avant de l'afficher.
3. Qu'est-ce que l'opérateur modulo et à quoi sert-il dans ce projet ?
L'opérateur modulo renvoie le reste d'une division entière. Dans ce projet, il permet de calculer le nombre de secondes restantes une fois les minutes complètes retirées, par exemple 125 modulo 60 donne 5, ce qui correspond bien aux 5 secondes restantes après 2 minutes complètes.
4. Pourquoi utiliser une variable booléenne pour gérer la pause plutôt qu'un bloc dédié ?
Scratch ne propose pas de bloc natif pour mettre en pause un script précis pendant son exécution. L'utilisation d'une variable de contrôle, testée en permanence par une condition, est la méthode standard pour simuler ce comportement de pause de manière fiable.
5. Peut-on créer un compte à rebours plutôt qu'un chronomètre qui avance ?
Oui, il suffit d'initialiser la variable temps avec la valeur de départ souhaitée, par exemple 60, puis de la faire décroître avec un bloc « ajouter -1 à temps » plutôt que « ajouter 1 », en ajoutant une condition d'arrêt lorsque la variable atteint zéro.
6. Ce projet peut-il être noté dans le cadre d'une évaluation de technologie ?
Oui, ce projet se prête très bien à une évaluation, car il permet de vérifier la maîtrise de plusieurs compétences combinées : gestion du temps, opérateurs mathématiques, et gestion d'état avec une variable de contrôle, tout en restant suffisamment court pour être réalisé et testé en une séance.
0 commentaire