Poser les bases : lire, écrire et prédire une suite d'instructions, puis composer ses propres algorithmes linéaires pour atteindre un objectif.

Transposer chaque algorithme au robot réel : le piloter pas à pas, enregistrer un programme et relever un défi de parcours en binôme.

Découvrir la répétition : remplacer une suite d'instructions identiques par une boucle et repérer le motif répétitif d'un parcours.

Réécrire un trajet du robot avec une boucle et lui faire tracer un carré à partir de son motif « avancer + tourner ».

Passer à l'écran : prendre en main l'interface ScratchJr, déclencher des actions par événement et modifier l'apparence d'un personnage par le code.

Prendre en main le robot lui-même — l'allumer, reconnaître boutons et capteurs — et le faire réagir à un bouton, une LED ou un son.

Faire vivre une scène : actions simultanées, changements de décor automatiques, sons et apparitions pour créer une courte animation.

Programmer le robot en autonomie : réactions parallèles, comportement différé (avance puis s'arrête et clignote), entrée en scène sonore.

Faire communiquer les personnages : envoyer et recevoir des messages, enchaîner des événements et fabriquer des boutons de commande.

Faire dialoguer robot et enfant : signaux lumière/son entre deux robots, bouton physique et télécommande maison à quatre directions.

Réagir à une collision : déclencher une action ou un message quand deux personnages se touchent, et amorcer un mini-jeu.

Détecter le contact d'un obstacle — s'arrêter, changer de direction, signaler — et construire le parcours à obstacles du mini-jeu.

Mener un projet collectif : choisir un thème, répartir les rôles, assembler les parties programmées par chacun et présenter le jeu.

Imaginer en groupe une mission robot, programmer chacun une portion du parcours, l'assembler en un trajet complet et le démontrer.

Réaliser un projet personnel de bout en bout, en autonomie, en mobilisant les notions de l'année, puis le présenter à la classe.

Construire le projet officiel « Mission robot découverte » — départ, virage, arrivée — programmé seul et présenté en démonstration finale.

Passer de ScratchJr à Scratch : empiler des blocs pour un algorithme linéaire, réutiliser la boucle, fixer une position de départ et déclencher par événement.

Rejouer chaque notion sur le robot : pilotage pas à pas, figure en boucle (carré), marque de départ précise et déclenchement par bouton dédié.

Maîtriser le repère de la scène : coordonnées x/y, orientation vers un point, rotations en degrés et synchronisation par message — projet animation.

Travailler l'espace réel : repères au sol, orientation vers une cible, virage à 90° vérifié, signal de position et chorégraphie de déplacements.

Introduire la décision : condition « si… sinon », coordonnées dynamiques, procédures réutilisables, puis concevoir, tester et présenter un mini-jeu.

Rendre le robot autonome : arrêt sur détection d'obstacle, poursuite d'une cible, bouton-procédure regroupant plusieurs commandes, défi conçu et testé.

Combiner les conditions : opérateurs ET / OU / PAS, boucle « répéter jusqu'à », hasard, zones de la scène — projet de groupe.

Appliquer la logique aux capteurs : réagir si deux capteurs sont d'accord, avancer jusqu'à un obstacle, angle légèrement aléatoire, zone d'arrivée au sol.

Manipuler des données qui changent : compteur de boucle, types nombre / texte, score de jeu, variable-paramètre — projet chatbot.

Donner de la mémoire au robot : compter ses tours, stocker une distance mesurée, tenir un score d'obstacles évités, régler sa vitesse, « répondre » à une question.

Découvrir le modèle réutilisable : créer des clones, distinguer variables locales et globales, ajouter une interface — jeu « Miroirs ».

Répéter et synchroniser : rejouer une même figure comme des « clones », séparer réglage du jour et réglage permanent, faire évoluer deux robots en miroir.

Planifier, programmer en autonomie et présenter un projet personnel réunissant toutes les notions du niveau — remise des diplômes.

Réaliser le projet officiel « Robot danseur ou robot explorateur » : scénario choisi, chorégraphie ou parcours réglé, démonstration finale.

Explorer librement l'interface, déplacer son avatar, ouvrir l'inventaire

Redécouvrir les commandes de base du robot, mais chronométrées pour la première fois

Dessiner une composition simple à partir de points et de lignes

Dessiner un motif simple qui servira de « carte à reconnaître » pour la caméra IA du mBot2

Faire ses premiers pas avec l'Agent : le faire avancer, le faire miner un bloc

Rencontre du « vrai » robot comme équivalent physique de l'Agent : mêmes commandes de base

Manipuler des formes 3D simples dans un logiciel, puis placer plusieurs objets dans une scène 3D

Découvrir comment un objet 3D pourrait devenir un futur accessoire fixé sur le mBot2 (pince, décor), puis réfléchir à l'espace disponible sur le châssis pour le fixer

Explorer un début d'histoire préparé et identifier l'objectif du personnage

Lancement d'un « parcours-aventure » chronométré à plusieurs étapes pour le robot

Découper ou dessiner des silhouettes simples

Découper des silhouettes-obstacles en carton pour le prochain parcours du robot

Explorer le logiciel, placer un premier objet dans la scène, puis le déplacer en modifiant ses coordonnées

Prise en main d'un nouveau capteur du robot (ex

Sculpter un relief simple et ajouter de la végétation, puis ajouter différents types de végétation et de reliefs

Aménager un décor physique (obstacles « arbres » en carton) pour le parcours robot, puis le compléter en variant les couleurs de sol (zones colorées à détecter)

Discuter en groupe : qu'est-ce qui rend un jeu amusant ?

Discussion : qu'est-ce qu'un « défi robot » bien conçu (règles claires, difficulté progressive) ?

Personnaliser l'apparence d'un premier personnage

Le robot devient un « personnage » du parcours : lui donner un nom, une personnalité (couleur LED, son)

Programmer la collecte et l'affichage d'objets ramassés

Le robot « collecte » des jetons posés sur le parcours en les détectant

Observer et discuter des mécaniques d'un jeu de course simple

Introduction au « suivi de ligne » comme mini-simulateur de course robotique

Observer plusieurs sites simples et identifier leurs points communs

Découvrir le mode texte de mBlock 5 (bascule blocs → code) sur le mBot2 : première bascule vers le vrai code, en miroir du passage au HTML

Écrire et exécuter ses premières lignes de Python

Exécuter un premier script Python sur le mBot2 (mBlock 5) qui fait avancer le robot

Changer les couleurs et le fond d'une page

Modifier une variable de couleur LED en écrivant directement sa valeur en code

Programmer un test simple (pair / impair, majeur / mineur)

Traduire « détection → décision » : si le capteur mesure moins de 15 cm, le robot s'arrête

Écrire ses premières balises (titre, paragraphe)

Repérer la syntaxe (mots-clés) du code et la comparer aux mots-clés du code robot (avancer, tourner, attendre)

Transformer un bloc de code répété en fonction appelée plusieurs fois

Créer une fonction « virage_droite() » réutilisée à chaque coin du parcours

Écrire un sélecteur qui cible tous les paragraphes

Introduire la variable comme « sélecteur » de valeur réutilisable (vitesse, couleur définie une fois)

Dessiner des lignes et des formes simples en avançant et en tournant

Faire le parallèle entre la « tortue » à l'écran et le robot au sol : mêmes ordres, avancer et tourner

Analyser la structure d'une page bien organisée

Planifier la structure d'un programme robot (début, boucle principale, fin)

Manipuler des objets prêts à l'emploi et appeler leurs méthodes

Voir le robot comme un objet : propriétés (vitesse, LED) et méthodes (avancer, tourner, klaxonner)

Placer plusieurs éléments dans un même conteneur

Regrouper plusieurs instructions dans une fonction — un « conteneur » de code réutilisable

Afficher une fenêtre, un fond et un premier élément à l'écran

Comparer la boucle de jeu à la boucle principale d'un programme robot (lire, décider, agir)

Ajouter un effet au survol d'un bouton

Ajouter une réaction « au contact » (équivalent pseudo-événement) : bip quand le capteur touche un obstacle

Analyser et corriger des programmes fournis avec des erreurs

Déboguer en équipe un programme robot bugué (condition inversée, mauvaise valeur)

Appliquer un dégradé de couleur à un fond

Faire varier progressivement (dégradé) la vitesse ou la couleur LED du mBot2

Chaque élève présente son meilleur projet (jeu, dessin Turtle)

Démonstration finale du robot (parcours ou jeu physique) intégrée à la présentation de fin d'année 1

Construire une interface web solide : HTML sémantique, CSS (sélecteurs, box model), puis intégration fidèle d'une maquette responsive.

Documenter le montage du robot sur la page, puis planifier sur papier un parcours avant de le construire, comme une maquette web.

Structurer les données et le code en Python : exceptions, listes, dictionnaires, fonctions, modules, puis fichiers et persistance.

Rendre un programme robot robuste aux erreurs capteur, puis tenir un journal de bord des essais sauvegardé et rechargé.

Créer une application de bureau avec PyQt : interface graphique, gestion d'état avec le projet Memory, score et tests de finalisation.

Concevoir le tableau de bord d'un robot et afficher ses essais et ses temps dans l'interface.

Rendre le web interactif en JavaScript : variables et fonctions, DOM et événements, conditions et tableaux, temps différé et stockage — jusqu'au mini-quiz.

Comparer les concepts JavaScript aux notions déjà connues en Python sur le robot, puis associer certaines réponses du quiz à une action du robot.

Adopter Git et VS Code, travailler avec des branches et des revues de code, puis mener un projet d'équipe jusqu'au déploiement.

Versionner aussi le programme du robot et construire un volet physique cohérent avec le projet de groupe.

Structurer un jeu de labyrinthe en classes avec PyGame : boucle de jeu, collisions, score et niveaux, jusqu'à la présentation finale.

Réorganiser le programme du robot en objets simples et faire résoudre au robot un vrai labyrinthe chronométré.

Comprendre l'architecture d'un système embarqué (capteur → microcontrôleur → actionneur), câbler une breadboard, puis piloter un servomoteur.

Passer du robot pédagogique mBot2 à un premier prototype ESP32/Arduino avec capteur, décision et action.

Documenter et publier ses projets dans un portfolio numérique, puis présenter une démonstration live devant la classe.

Démontrer le prototype robotique et expliquer le rôle de ses principaux composants.

Réactiver algorithmes, structures de données et POO, puis adopter tests, Git et qualité de code proches des pratiques professionnelles.

Reprogrammer un parcours robot de zéro et versionner les corrections apportées à un programme testé méthodiquement.

Passer d'un besoin utilisateur à un MVP : persona, user flow, wireframe, puis prototype testé et amélioré par les retours.

Imaginer et tester une interface de télécommande ou de supervision d'un robot connecté.

Analyser des données avec Pandas : charger et filtrer, nettoyer et regrouper, visualiser puis formuler une hypothèse — jusqu'au pitch.

Importer et nettoyer les mesures d'essais robot, comparer les parcours et tracer leur évolution.

Comprendre le machine learning : entraînement et test, évaluation d'un modèle de classification, surapprentissage et biais.

Discuter d'un cas où un robot classerait une situation à partir de ses capteurs, en restant critique sur les limites du modèle.

Développer un backend Python : serveur et routes, templates et formulaires, base SQLite, sessions et sécurité — jusqu'au tableau de bord.

Imaginer puis construire un tableau de bord affichant en direct les essais et mesures du robot.

Créer un mini-jeu 3D avec Panda3D : scène et chargement de carte, contrôle du joueur et boucle de jeu, collisions et level design.

Comparer la carte virtuelle à un parcours physique réel, puis créer ce parcours en écho au niveau 3D.

Construire un objet connecté : ESP32/CyberPi et lecture de capteurs, servomoteur et PWM, communication Wi-Fi/Bluetooth, ouverture Raspberry Pi.

Comparer ce système autonome au mBot2, puis piloter à distance un signal ou un comportement du robot connecté.

Cadrer un grand projet personnel (data, IA, backend, 3D ou IoT), le développer en deux sprints testés, puis le documenter jusqu'à la soutenance.

Décider des contraintes matérielles du projet, construire et tester son volet robotique ou connecté, puis le démontrer en soutenance finale.